@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/running-apex-tests/assets/bulk-test.cls

@@ -0,0 +1,255 @@
+/**
+ * @description Bulk testing template for trigger and service validation
+ *              Tests with 251+ records to ensure bulkification compliance.
+ *              251 records crosses the 200-record trigger batch boundary.
+ * @created     {{Date}}
+ */
+@IsTest
+private class {{ClassName}}BulkTest {
+
+    // Record counts for different test scenarios
+    private static final Integer BULK_SIZE = 251;       // Crosses 200-batch boundary
+    private static final Integer LARGE_BULK_SIZE = 501; // Multiple batch boundaries
+    private static final Integer SINGLE_BATCH = 200;    // Single batch (edge case)
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // BULK INSERT TESTS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Tests bulk insert with 251 records
+     *              Verifies trigger handles multiple batch chunks correctly
+     */
+    @IsTest
+    static void testBulkInsert_251Records_AllProcessed() {
+        // GIVEN
+        List<{{ObjectName}}> records = TestDataFactory.create{{ObjectName}}s(BULK_SIZE);
+
+        // WHEN
+        Test.startTest();
+        Database.SaveResult[] results = Database.insert(records, false);
+        Test.stopTest();
+
+        // THEN - All records should be successfully inserted
+        Integer successCount = 0;
+        Integer failCount = 0;
+        for (Database.SaveResult sr : results) {
+            if (sr.isSuccess()) {
+                successCount++;
+            } else {
+                failCount++;
+                System.debug('Insert failed: ' + sr.getErrors()[0].getMessage());
+            }
+        }
+
+        Assert.areEqual(BULK_SIZE, successCount,
+            'All ' + BULK_SIZE + ' records should insert successfully');
+        Assert.areEqual(0, failCount, 'No records should fail');
+
+        // Verify governor limits
+        assertGovernorLimitsNotExceeded();
+    }
+
+    /**
+     * @description Tests bulk insert at exact batch boundary (200 records)
+     */
+    @IsTest
+    static void testBulkInsert_ExactBatchSize_AllProcessed() {
+        // GIVEN
+        List<{{ObjectName}}> records = TestDataFactory.create{{ObjectName}}s(SINGLE_BATCH);
+
+        // WHEN
+        Test.startTest();
+        insert records;
+        Test.stopTest();
+
+        // THEN
+        Integer count = [SELECT COUNT() FROM {{ObjectName}}];
+        Assert.areEqual(SINGLE_BATCH, count,
+            'All ' + SINGLE_BATCH + ' records should be inserted');
+        assertGovernorLimitsNotExceeded();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // BULK UPDATE TESTS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Tests bulk update with 251 records
+     *              Verifies update triggers handle multiple batches
+     */
+    @IsTest
+    static void testBulkUpdate_251Records_AllUpdated() {
+        // GIVEN - Insert records first
+        List<{{ObjectName}}> records = TestDataFactory.create{{ObjectName}}s(BULK_SIZE);
+        insert records;
+
+        // Modify all records
+        for ({{ObjectName}} rec : records) {
+            // TODO: Update fields that trigger logic
+            // rec.SomeField__c = 'Updated Value';
+        }
+
+        // WHEN
+        Test.startTest();
+        Database.SaveResult[] results = Database.update(records, false);
+        Test.stopTest();
+
+        // THEN
+        Integer successCount = 0;
+        for (Database.SaveResult sr : results) {
+            if (sr.isSuccess()) {
+                successCount++;
+            }
+        }
+
+        Assert.areEqual(BULK_SIZE, successCount,
+            'All ' + BULK_SIZE + ' records should update successfully');
+        assertGovernorLimitsNotExceeded();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // BULK DELETE TESTS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Tests bulk delete with 251 records
+     *              Verifies delete triggers handle cleanup correctly
+     */
+    @IsTest
+    static void testBulkDelete_251Records_AllDeleted() {
+        // GIVEN
+        List<{{ObjectName}}> records = TestDataFactory.create{{ObjectName}}s(BULK_SIZE);
+        insert records;
+
+        // WHEN
+        Test.startTest();
+        Database.DeleteResult[] results = Database.delete(records, false);
+        Test.stopTest();
+
+        // THEN
+        Integer successCount = 0;
+        for (Database.DeleteResult dr : results) {
+            if (dr.isSuccess()) {
+                successCount++;
+            }
+        }
+
+        Assert.areEqual(BULK_SIZE, successCount,
+            'All ' + BULK_SIZE + ' records should delete successfully');
+
+        Integer remainingCount = [SELECT COUNT() FROM {{ObjectName}}];
+        Assert.areEqual(0, remainingCount, 'No records should remain');
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // MIXED DML BULK TESTS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Tests mixed operations in bulk
+     *              Verifies partial success scenarios are handled
+     */
+    @IsTest
+    static void testBulkMixedOperations_PartialSuccess() {
+        // GIVEN - Some valid, some invalid records
+        List<{{ObjectName}}> validRecords = TestDataFactory.create{{ObjectName}}s(200);
+        List<{{ObjectName}}> invalidRecords = new List<{{ObjectName}}>();
+
+        // Create invalid records (missing required fields or validation failures)
+        for (Integer i = 0; i < 51; i++) {
+            invalidRecords.add(new {{ObjectName}}(
+                // TODO: Set up record that will fail validation
+            ));
+        }
+
+        List<{{ObjectName}}> allRecords = new List<{{ObjectName}}>();
+        allRecords.addAll(validRecords);
+        allRecords.addAll(invalidRecords);
+
+        // WHEN - Insert with allOrNone = false
+        Test.startTest();
+        Database.SaveResult[] results = Database.insert(allRecords, false);
+        Test.stopTest();
+
+        // THEN - Count successes and failures
+        Integer successCount = 0;
+        Integer failCount = 0;
+        for (Database.SaveResult sr : results) {
+            if (sr.isSuccess()) {
+                successCount++;
+            } else {
+                failCount++;
+            }
+        }
+
+        // Verify partial success handled correctly
+        Assert.isTrue(successCount > 0, 'Some records should succeed');
+        // Note: Uncomment if you expect failures
+        // Assert.isTrue(failCount > 0, 'Some records should fail validation');
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // GOVERNOR LIMIT VERIFICATION
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Helper method to verify governor limits not exceeded
+     *              Call after Test.stopTest() to check limit usage
+     */
+    private static void assertGovernorLimitsNotExceeded() {
+        // SOQL Queries (limit: 100)
+        Assert.isTrue(Limits.getQueries() < 90,
+            'SOQL queries approaching limit: ' + Limits.getQueries() + '/100');
+
+        // DML Statements (limit: 150)
+        Assert.isTrue(Limits.getDmlStatements() < 140,
+            'DML statements approaching limit: ' + Limits.getDmlStatements() + '/150');
+
+        // DML Rows (limit: 10,000)
+        Assert.isTrue(Limits.getDmlRows() < 9500,
+            'DML rows approaching limit: ' + Limits.getDmlRows() + '/10000');
+
+        // Heap Size (limit: 6MB sync, 12MB async)
+        Assert.isTrue(Limits.getHeapSize() < 5000000,
+            'Heap size approaching limit: ' + Limits.getHeapSize() + '/6000000');
+
+        // CPU Time (limit: 10,000ms sync, 60,000ms async)
+        Assert.isTrue(Limits.getCpuTime() < 9000,
+            'CPU time approaching limit: ' + Limits.getCpuTime() + '/10000');
+
+        System.debug('═══════════════════════════════════════════════════════');
+        System.debug('GOVERNOR LIMIT USAGE:');
+        System.debug('  SOQL Queries: ' + Limits.getQueries() + '/100');
+        System.debug('  DML Statements: ' + Limits.getDmlStatements() + '/150');
+        System.debug('  DML Rows: ' + Limits.getDmlRows() + '/10000');
+        System.debug('  Heap Size: ' + Limits.getHeapSize() + '/6000000');
+        System.debug('  CPU Time: ' + Limits.getCpuTime() + 'ms /10000ms');
+        System.debug('═══════════════════════════════════════════════════════');
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // STRESS TESTS (Optional - Run sparingly)
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Stress test with 501 records (multiple batch boundaries)
+     *              Use sparingly - consumes significant test execution time
+     */
+    @IsTest
+    static void testStressTest_501Records_AllProcessed() {
+        // GIVEN
+        List<{{ObjectName}}> records = TestDataFactory.create{{ObjectName}}s(LARGE_BULK_SIZE);
+
+        // WHEN
+        Test.startTest();
+        insert records;
+        Test.stopTest();
+
+        // THEN
+        Integer count = [SELECT COUNT() FROM {{ObjectName}}];
+        Assert.areEqual(LARGE_BULK_SIZE, count,
+            'All ' + LARGE_BULK_SIZE + ' records should be processed');
+        assertGovernorLimitsNotExceeded();
+    }
+}

package/skills/running-apex-tests/assets/dml-mock.cls

@@ -0,0 +1,339 @@
+/**
+ * DML Mocking Framework
+ *
+ * Enables true unit testing by replacing database operations with in-memory tracking.
+ * Tests using this pattern run ~35x faster than tests with actual DML.
+ *
+ * See: references/mocking-patterns.md for usage guidance
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INTERFACE: IDML
+// Define the contract for DML operations
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Interface for DML operations - enables dependency injection
+ */
+public interface IDML {
+    void doInsert(SObject record);
+    void doInsert(List<SObject> records);
+    void doUpdate(SObject record);
+    void doUpdate(List<SObject> records);
+    void doUpsert(SObject record);
+    void doUpsert(List<SObject> records);
+    void doDelete(SObject record);
+    void doDelete(List<SObject> records);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PRODUCTION: DML
+// Performs actual database operations
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Production implementation performing real database operations
+ */
+public class DML implements IDML {
+
+    public void doInsert(SObject record) {
+        insert record;
+    }
+
+    public void doInsert(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            insert records;
+        }
+    }
+
+    public void doUpdate(SObject record) {
+        update record;
+    }
+
+    public void doUpdate(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            update records;
+        }
+    }
+
+    public void doUpsert(SObject record) {
+        upsert record;
+    }
+
+    public void doUpsert(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            upsert records;
+        }
+    }
+
+    public void doDelete(SObject record) {
+        delete record;
+    }
+
+    public void doDelete(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            delete records;
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TEST MOCK: DMLMock
+// Tracks operations without hitting the database
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Mock DML implementation for fast unit tests
+ *
+ * Usage:
+ *   DMLMock.reset();
+ *   MyService service = new MyService(new DMLMock());
+ *   service.doSomething();
+ *   Assert.areEqual(1, DMLMock.InsertedRecords.size());
+ */
+@IsTest
+public class DMLMock implements IDML {
+
+    // ═══════════════════════════════════════════════════════════════════
+    // TRACKED OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════
+
+    public static List<SObject> InsertedRecords = new List<SObject>();
+    public static List<SObject> UpdatedRecords = new List<SObject>();
+    public static List<SObject> UpsertedRecords = new List<SObject>();
+    public static List<SObject> DeletedRecords = new List<SObject>();
+
+    // Counter for generating unique fake IDs
+    private static Integer idCounter = 1;
+
+    // ═══════════════════════════════════════════════════════════════════
+    // DML OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════
+
+    public void doInsert(SObject record) {
+        doInsert(new List<SObject>{ record });
+    }
+
+    public void doInsert(List<SObject> records) {
+        if (records == null || records.isEmpty()) {
+            return;
+        }
+        for (SObject record : records) {
+            // Generate fake ID to simulate database insert
+            if (record.Id == null) {
+                record.Id = generateFakeId(record.getSObjectType());
+            }
+            InsertedRecords.add(record);
+        }
+    }
+
+    public void doUpdate(SObject record) {
+        doUpdate(new List<SObject>{ record });
+    }
+
+    public void doUpdate(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            UpdatedRecords.addAll(records);
+        }
+    }
+
+    public void doUpsert(SObject record) {
+        doUpsert(new List<SObject>{ record });
+    }
+
+    public void doUpsert(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            for (SObject record : records) {
+                if (record.Id == null) {
+                    record.Id = generateFakeId(record.getSObjectType());
+                }
+            }
+            UpsertedRecords.addAll(records);
+        }
+    }
+
+    public void doDelete(SObject record) {
+        doDelete(new List<SObject>{ record });
+    }
+
+    public void doDelete(List<SObject> records) {
+        if (records != null && !records.isEmpty()) {
+            DeletedRecords.addAll(records);
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // UTILITY METHODS
+    // ═══════════════════════════════════════════════════════════════════
+
+    /**
+     * Reset all tracked operations - call at start of each test
+     */
+    public static void reset() {
+        InsertedRecords.clear();
+        UpdatedRecords.clear();
+        UpsertedRecords.clear();
+        DeletedRecords.clear();
+        idCounter = 1;
+    }
+
+    /**
+     * Generate a valid Salesforce ID for testing
+     * Uses the object's key prefix for realistic IDs
+     */
+    private static Id generateFakeId(Schema.SObjectType sObjectType) {
+        String keyPrefix = sObjectType.getDescribe().getKeyPrefix();
+        if (keyPrefix == null) {
+            keyPrefix = '000';  // Fallback for objects without prefix
+        }
+        String idBody = String.valueOf(idCounter++).leftPad(12, '0');
+        return Id.valueOf(keyPrefix + idBody);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // HELPER METHODS FOR ASSERTIONS
+    // ═══════════════════════════════════════════════════════════════════
+
+    /**
+     * Get inserted records of a specific SObject type
+     */
+    public static List<SObject> getInsertedOfType(Schema.SObjectType sObjectType) {
+        List<SObject> result = new List<SObject>();
+        for (SObject record : InsertedRecords) {
+            if (record.getSObjectType() == sObjectType) {
+                result.add(record);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Get updated records of a specific SObject type
+     */
+    public static List<SObject> getUpdatedOfType(Schema.SObjectType sObjectType) {
+        List<SObject> result = new List<SObject>();
+        for (SObject record : UpdatedRecords) {
+            if (record.getSObjectType() == sObjectType) {
+                result.add(record);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Get deleted records of a specific SObject type
+     */
+    public static List<SObject> getDeletedOfType(Schema.SObjectType sObjectType) {
+        List<SObject> result = new List<SObject>();
+        for (SObject record : DeletedRecords) {
+            if (record.getSObjectType() == sObjectType) {
+                result.add(record);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Check if any records of a specific type were inserted
+     */
+    public static Boolean wasInserted(Schema.SObjectType sObjectType) {
+        return !getInsertedOfType(sObjectType).isEmpty();
+    }
+
+    /**
+     * Check if any records of a specific type were updated
+     */
+    public static Boolean wasUpdated(Schema.SObjectType sObjectType) {
+        return !getUpdatedOfType(sObjectType).isEmpty();
+    }
+
+    /**
+     * Check if any records of a specific type were deleted
+     */
+    public static Boolean wasDeleted(Schema.SObjectType sObjectType) {
+        return !getDeletedOfType(sObjectType).isEmpty();
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE: Service Using Injected DML
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Example service class demonstrating DML injection
+ */
+public class AccountService {
+
+    private IDML dml;
+
+    // Production constructor - uses real DML
+    public AccountService() {
+        this(new DML());
+    }
+
+    // Test constructor - accepts mock DML
+    @TestVisible
+    private AccountService(IDML dml) {
+        this.dml = dml;
+    }
+
+    public Id createAccount(Account acc) {
+        if (acc == null) {
+            throw new IllegalArgumentException('Account cannot be null');
+        }
+        dml.doInsert(acc);
+        return acc.Id;
+    }
+
+    public void updateAccounts(List<Account> accounts) {
+        dml.doUpdate(accounts);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE: Test Class Using DML Mock
+// ═══════════════════════════════════════════════════════════════════════════
+
+@IsTest
+private class AccountServiceTest {
+
+    @IsTest
+    static void testCreateAccount_Success() {
+        // Arrange
+        DMLMock.reset();
+        AccountService service = new AccountService(new DMLMock());
+        Account testAcc = new Account(Name = 'Test Corp', Industry = 'Technology');
+
+        // Act
+        Test.startTest();
+        Id accountId = service.createAccount(testAcc);
+        Test.stopTest();
+
+        // Assert
+        Assert.isNotNull(accountId, 'Should have generated ID');
+        Assert.areEqual(1, DMLMock.InsertedRecords.size(), 'Should have 1 insert');
+        Assert.isTrue(DMLMock.wasInserted(Account.SObjectType), 'Account was inserted');
+
+        Account inserted = (Account) DMLMock.InsertedRecords[0];
+        Assert.areEqual('Test Corp', inserted.Name, 'Name should match');
+        Assert.areEqual('Technology', inserted.Industry, 'Industry should match');
+    }
+
+    @IsTest
+    static void testCreateAccount_NullInput_ThrowsException() {
+        // Arrange
+        DMLMock.reset();
+        AccountService service = new AccountService(new DMLMock());
+
+        // Act/Assert
+        try {
+            service.createAccount(null);
+            Assert.fail('Expected IllegalArgumentException');
+        } catch (IllegalArgumentException e) {
+            Assert.isTrue(e.getMessage().contains('null'), 'Error should mention null');
+        }
+
+        // Verify no DML occurred
+        Assert.areEqual(0, DMLMock.InsertedRecords.size(), 'No records should be inserted');
+    }
+}