@salesforce/afv-skills 1.5.0 → 1.5.1

package/skills/generating-apex-test/assets/test-class-template.cls

@@ -0,0 +1,124 @@
+/**
+ * @description Test class for {ClassUnderTest}.
+ *              Tests bulk operations (200+ records), positive/negative paths,
+ *              and exception handling.
+ * @author Generated by Apex Test Writer Skill
+ */
+@isTest
+private class {ClassUnderTest}Test {
+
+    // ─── Test Setup ───────────────────────────────────────────────────────
+
+    @TestSetup
+    static void setupTestData() {
+        // Create shared test data using TestDataFactory
+        // List<Account> accounts = TestDataFactory.createAccounts(200, true);
+    }
+
+    // ─── Positive Tests ───────────────────────────────────────────────────
+
+    @isTest
+    static void shouldPerformExpectedBehavior_WhenValidInput() {
+        // Given: Setup specific test state
+        // List<Account> accounts = [SELECT Id, Name FROM Account];
+
+        // When: Execute the code under test
+        Test.startTest();
+        // {ClassUnderTest}.methodUnderTest(params);
+        Test.stopTest();
+
+        // Then: Assert expected outcomes
+        // System.assertEquals(expected, actual, 'Descriptive failure message');
+    }
+
+    @isTest
+    static void shouldHandleBulkRecords_WhenProcessing200() {
+        // Given: 200+ records to verify bulkification
+        // List<Account> accounts = [SELECT Id FROM Account];
+        // System.assertEquals(200, accounts.size(), 'Should have 200 test records');
+
+        // When
+        Test.startTest();
+        // {ClassUnderTest}.bulkMethod(accounts);
+        Test.stopTest();
+
+        // Then: Verify all records processed
+        // List<Account> results = [SELECT Id, Status__c FROM Account];
+        // for (Account acc : results) {
+        //     System.assertEquals('Processed', acc.Status__c, 'All records should be processed');
+        // }
+    }
+
+    // ─── Negative Tests ───────────────────────────────────────────────────
+
+    @isTest
+    static void shouldThrowException_WhenNullInput() {
+        Boolean exceptionThrown = false;
+        String exceptionMessage = '';
+
+        Test.startTest();
+        try {
+            // {ClassUnderTest}.methodUnderTest(null);
+        } catch (Exception e) {
+            exceptionThrown = true;
+            exceptionMessage = e.getMessage();
+        }
+        Test.stopTest();
+
+        System.assert(exceptionThrown, 'Exception should be thrown for null input');
+        System.assert(exceptionMessage.contains('cannot be null'),
+            'Exception message should mention null input');
+    }
+
+    @isTest
+    static void shouldReturnEmpty_WhenEmptyInput() {
+        Test.startTest();
+        // List<SObject> results = {ClassUnderTest}.methodUnderTest(new List<Id>());
+        Test.stopTest();
+
+        // System.assert(results.isEmpty(), 'Should return empty list for empty input');
+    }
+
+    // ─── Edge Case Tests ──────────────────────────────────────────────────
+
+    @isTest
+    static void shouldHandleMixedRecords_WhenSomeQualify() {
+        // Given: Mix of qualifying and non-qualifying records
+        // List<Account> accounts = [SELECT Id, Status__c FROM Account];
+        // Integer half = accounts.size() / 2;
+        // for (Integer i = 0; i < half; i++) {
+        //     accounts[i].Status__c = 'Qualifying';
+        // }
+        // update accounts;
+
+        // When
+        Test.startTest();
+        // {ClassUnderTest}.conditionalMethod(accounts);
+        Test.stopTest();
+
+        // Then: Only qualifying records should be affected
+        // List<Account> qualifying = [SELECT Id FROM Account WHERE Processed__c = true];
+        // System.assertEquals(half, qualifying.size(), 'Only qualifying records should be processed');
+    }
+
+    // ─── Governor Limit Tests ─────────────────────────────────────────────
+
+    @isTest
+    static void shouldNotExceedGovernorLimits_WhenBulkProcessing() {
+        // Given
+        // List<Account> accounts = [SELECT Id FROM Account];
+
+        Test.startTest();
+        // {ClassUnderTest}.heavyMethod(accounts);
+        Test.stopTest();
+
+        System.assert(Limits.getDmlStatements() < Limits.getLimitDmlStatements(),
+            'Should not exceed DML statement limit');
+        System.assert(Limits.getQueries() < Limits.getLimitQueries(),
+            'Should not exceed SOQL query limit');
+    }
+
+    // ─── Helper Methods ───────────────────────────────────────────────────
+
+    // Add test-specific helper methods here
+}

package/skills/generating-apex-test/assets/test-data-factory-template.cls

@@ -0,0 +1,112 @@
+/**
+ * @description Centralized factory for creating test data with sensible defaults.
+ *              All methods accept a doInsert flag for flexibility.
+ *              Bulk methods create multiple records; single-record methods delegate to bulk.
+ * @author Generated by Apex Test Writer Skill
+ */
+@isTest
+public class TestDataFactory {
+
+    // ─── Accounts ─────────────────────────────────────────────────────────
+
+    public static List<Account> createAccounts(Integer count, Boolean doInsert) {
+        List<Account> accounts = new List<Account>();
+        for (Integer i = 0; i < count; i++) {
+            accounts.add(new Account(
+                Name = 'Test Account ' + i,
+                BillingCity = 'San Francisco',
+                BillingState = 'CA',
+                BillingCountry = 'USA',
+                Industry = 'Technology',
+                Type = 'Customer'
+            ));
+        }
+        if (doInsert) insert accounts;
+        return accounts;
+    }
+
+    public static Account createAccount(Boolean doInsert) {
+        return createAccounts(1, doInsert)[0];
+    }
+
+    // ─── Contacts ─────────────────────────────────────────────────────────
+
+    public static List<Contact> createContacts(List<Account> accounts, Integer countPerAccount, Boolean doInsert) {
+        List<Contact> contacts = new List<Contact>();
+        Integer idx = 0;
+        for (Account acc : accounts) {
+            for (Integer i = 0; i < countPerAccount; i++) {
+                contacts.add(new Contact(
+                    FirstName = 'Test',
+                    LastName = 'Contact ' + idx,
+                    Email = 'test.contact' + idx + '@example.com',
+                    AccountId = acc.Id
+                ));
+                idx++;
+            }
+        }
+        if (doInsert) insert contacts;
+        return contacts;
+    }
+
+    // ─── Opportunities ────────────────────────────────────────────────────
+
+    public static List<Opportunity> createOpportunities(List<Account> accounts, Integer countPerAccount, Boolean doInsert) {
+        List<Opportunity> opps = new List<Opportunity>();
+        Integer idx = 0;
+        for (Account acc : accounts) {
+            for (Integer i = 0; i < countPerAccount; i++) {
+                opps.add(new Opportunity(
+                    Name = 'Test Opportunity ' + idx,
+                    AccountId = acc.Id,
+                    StageName = 'Prospecting',
+                    CloseDate = Date.today().addDays(30),
+                    Amount = 10000 + (idx * 1000)
+                ));
+                idx++;
+            }
+        }
+        if (doInsert) insert opps;
+        return opps;
+    }
+
+    // ─── Users ────────────────────────────────────────────────────────────
+
+    public static User createUser(String profileName, Boolean doInsert) {
+        Profile p = [SELECT Id FROM Profile WHERE Name = :profileName LIMIT 1];
+        String uniqueKey = String.valueOf(DateTime.now().getTime());
+
+        User u = new User(
+            FirstName = 'Test',
+            LastName = 'User ' + uniqueKey,
+            Email = 'testuser' + uniqueKey + '@example.com',
+            Username = 'testuser' + uniqueKey + '@example.com.test',
+            Alias = 'tuser',
+            TimeZoneSidKey = 'America/Los_Angeles',
+            LocaleSidKey = 'en_US',
+            EmailEncodingKey = 'UTF-8',
+            LanguageLocaleKey = 'en_US',
+            ProfileId = p.Id
+        );
+        if (doInsert) insert u;
+        return u;
+    }
+
+    // ─── Field Override Pattern ────────────────────────────────────────────
+
+    public static Account createAccount(Map<String, Object> fieldOverrides, Boolean doInsert) {
+        Account acc = new Account(
+            Name = 'Test Account',
+            Industry = 'Technology'
+        );
+        for (String fieldName : fieldOverrides.keySet()) {
+            acc.put(fieldName, fieldOverrides.get(fieldName));
+        }
+        if (doInsert) insert acc;
+        return acc;
+    }
+
+    // ─── Custom Objects ───────────────────────────────────────────────────
+    // Add methods for your custom objects following the same pattern:
+    // public static List<MyObject__c> createMyObjects(Integer count, Boolean doInsert) { ... }
+}

package/skills/generating-apex-test/references/assertion-patterns.md

@@ -0,0 +1,165 @@
+# Assertion Patterns
+
+## Assertion Methods
+
+| Method | Use Case |
+|--------|----------|
+| `System.assertEquals(expected, actual, msg)` | Exact equality |
+| `System.assertNotEquals(expected, actual, msg)` | Value should differ |
+| `System.assert(condition, msg)` | Boolean condition |
+
+**Always include the third parameter (message)** - Makes test failures meaningful.
+
+## Good vs Bad Assertions
+
+### ❌ Bad: No message, tests coverage not behavior
+
+```apex
+System.assertEquals(true, result);
+System.assert(accounts.size() > 0);
+```
+
+### ✅ Good: Descriptive message, tests specific behavior
+
+```apex
+System.assertEquals(true, result, 'Service should return true for valid input');
+System.assertEquals(200, accounts.size(), 'All 200 accounts should be processed');
+```
+
+## Common Assertion Patterns
+
+### Collection Size
+
+```apex
+// Exact count
+System.assertEquals(200, results.size(), 'Should process all 200 records');
+
+// Not empty
+System.assert(!results.isEmpty(), 'Results should not be empty');
+
+// Empty
+System.assert(results.isEmpty(), 'No results expected for invalid input');
+```
+
+### Field Values
+
+```apex
+// Single record
+System.assertEquals('Processed', acc.Status__c, 'Account status should be updated to Processed');
+
+// All records in collection
+for (Account acc : updatedAccounts) {
+    System.assertEquals('Active', acc.Status__c, 
+        'Account ' + acc.Name + ' should have Active status');
+}
+```
+
+### Exception Testing
+
+```apex
+@isTest
+static void shouldThrowException_WhenInputInvalid() {
+    Boolean exceptionThrown = false;
+    String exceptionMessage = '';
+    
+    Test.startTest();
+    try {
+        MyService.process(null);
+    } catch (MyCustomException e) {
+        exceptionThrown = true;
+        exceptionMessage = e.getMessage();
+    }
+    Test.stopTest();
+    
+    System.assert(exceptionThrown, 'MyCustomException should be thrown for null input');
+    System.assert(exceptionMessage.contains('cannot be null'), 
+        'Exception message should mention null input');
+}
+```
+
+### DML Results
+
+```apex
+// Insert success
+Database.SaveResult[] results = Database.insert(accounts, false);
+for (Database.SaveResult sr : results) {
+    System.assert(sr.isSuccess(), 'Insert should succeed: ' + sr.getErrors());
+}
+
+// Expected failures
+Database.SaveResult sr = Database.insert(invalidAccount, false);
+System.assert(!sr.isSuccess(), 'Insert should fail for invalid data');
+System.assert(sr.getErrors()[0].getMessage().contains('REQUIRED_FIELD_MISSING'),
+    'Error should indicate missing required field');
+```
+
+### Comparing Objects
+
+```apex
+// Compare specific fields, not entire objects
+System.assertEquals(expected.Name, actual.Name, 'Names should match');
+System.assertEquals(expected.Status__c, actual.Status__c, 'Status should match');
+
+// Or use JSON for deep comparison (use sparingly)
+System.assertEquals(
+    JSON.serialize(expected), 
+    JSON.serialize(actual), 
+    'Objects should be identical'
+);
+```
+
+### Date/DateTime Assertions
+
+```apex
+// Exact date
+System.assertEquals(Date.today(), record.CreatedDate__c, 'Should be created today');
+
+// Date within range
+System.assert(record.DueDate__c >= Date.today(), 'Due date should be in the future');
+System.assert(record.DueDate__c <= Date.today().addDays(30), 
+    'Due date should be within 30 days');
+```
+
+### Null Checks
+
+```apex
+// Should be null
+System.assertEquals(null, result.ErrorMessage__c, 'No error expected for valid input');
+
+// Should not be null
+System.assertNotEquals(null, result.Id, 'Record should have been inserted');
+```
+
+## Anti-Patterns to Avoid
+
+### ❌ Testing implementation, not behavior
+
+```apex
+// Bad: Testing that a specific method was called
+System.assert(MyClass.methodWasCalled, 'Method should be called');
+
+// Good: Testing the observable outcome
+System.assertEquals('Expected Value', record.Field__c, 'Field should be updated');
+```
+
+### ❌ Overly generic assertions
+
+```apex
+// Bad: Passes for any non-empty result
+System.assert(results.size() > 0);
+
+// Good: Verifies exact expected count
+System.assertEquals(200, results.size(), 'All 200 records should be returned');
+```
+
+### ❌ Missing negative test assertions
+
+```apex
+// Bad: Only tests that no exception occurred
+MyService.process(data); // Test passes if no exception
+
+// Good: Verifies the actual outcome
+Result r = MyService.process(data);
+System.assertEquals('Success', r.status, 'Processing should succeed');
+System.assertEquals(0, r.errorCount, 'No errors should occur');
+```

package/skills/generating-apex-test/references/async-testing.md

@@ -0,0 +1,276 @@
+# Async Testing Patterns
+
+## Key Principle
+
+`Test.stopTest()` forces all async operations to execute synchronously, allowing assertions on their results.
+
+## Batch Apex Testing
+
+### Basic Batch Test
+
+```apex
+@isTest
+static void shouldProcessAllRecords_WhenBatchExecutes() {
+    // Given: Create test data
+    List<Account> accounts = TestDataFactory.createAccounts(200, true);
+    
+    // When: Execute batch
+    Test.startTest();
+    MyBatchClass batch = new MyBatchClass();
+    Id batchId = Database.executeBatch(batch, 200);
+    Test.stopTest(); // Forces batch to complete
+    
+    // Then: Verify results
+    List<Account> updated = [SELECT Id, Status__c FROM Account];
+    for (Account acc : updated) {
+        System.assertEquals('Processed', acc.Status__c, 
+            'Batch should update all account statuses');
+    }
+}
+```
+
+### Testing Batch with Failures
+
+```apex
+@isTest
+static void shouldLogErrors_WhenRecordsFail() {
+    // Given: Create mix of valid and invalid records
+    List<Account> accounts = TestDataFactory.createAccounts(198, true);
+    
+    // Create 2 accounts that will fail processing
+    List<Account> invalidAccounts = new List<Account>();
+    for (Integer i = 0; i < 2; i++) {
+        invalidAccounts.add(new Account(
+            Name = 'Invalid Account ' + i,
+            Invalid_Field__c = 'triggers_validation_error'
+        ));
+    }
+    insert invalidAccounts;
+    
+    // When
+    Test.startTest();
+    MyBatchClass batch = new MyBatchClass();
+    Database.executeBatch(batch, 50);
+    Test.stopTest();
+    
+    // Then
+    List<Error_Log__c> errors = [SELECT Id, Message__c FROM Error_Log__c];
+    System.assertEquals(2, errors.size(), 'Should log 2 failed records');
+}
+```
+
+### Testing Batch Scope
+
+```apex
+@isTest
+static void shouldRespectBatchSize() {
+    // Given
+    List<Account> accounts = TestDataFactory.createAccounts(250, true);
+    
+    Test.startTest();
+    MyBatchClass batch = new MyBatchClass();
+    Database.executeBatch(batch, 50); // 5 batches of 50
+    Test.stopTest();
+    
+    // Note: In tests, all batches execute but you can verify total processing
+    List<Account> processed = [SELECT Id FROM Account WHERE Processed__c = true];
+    System.assertEquals(250, processed.size(), 'All records should be processed');
+}
+```
+
+## Queueable Testing
+
+### Basic Queueable Test
+
+```apex
+@isTest
+static void shouldCompleteProcessing_WhenQueueableEnqueued() {
+    // Given
+    Account acc = TestDataFactory.createAccount(true);
+    
+    // When
+    Test.startTest();
+    MyQueueableClass queueable = new MyQueueableClass(acc.Id);
+    System.enqueueJob(queueable);
+    Test.stopTest(); // Forces queueable to complete
+    
+    // Then
+    Account updated = [SELECT Id, Status__c FROM Account WHERE Id = :acc.Id];
+    System.assertEquals('Processed', updated.Status__c, 
+        'Queueable should update account status');
+}
+```
+
+### Testing Queueable Chaining
+
+Chained queueables only execute the first job in tests:
+
+```apex
+@isTest
+static void shouldChainNextJob_WhenMoreRecordsExist() {
+    // Given: More records than one queueable can process
+    List<Account> accounts = TestDataFactory.createAccounts(500, true);
+    
+    Test.startTest();
+    // First queueable processes batch 1 and chains next
+    MyChainedQueueable queueable = new MyChainedQueueable(0, 100);
+    System.enqueueJob(queueable);
+    Test.stopTest();
+    
+    // Verify first batch processed
+    List<Account> processed = [SELECT Id FROM Account WHERE Processed__c = true];
+    System.assertEquals(100, processed.size(), 'First batch should process 100 records');
+    
+    // Verify chain was enqueued (check AsyncApexJob)
+    List<AsyncApexJob> jobs = [
+        SELECT Id, Status, JobType 
+        FROM AsyncApexJob 
+        WHERE ApexClass.Name = 'MyChainedQueueable'
+    ];
+    System.assert(jobs.size() >= 1, 'Chained job should be enqueued');
+}
+```
+
+### Testing Queueable with Callouts
+
+```apex
+@isTest
+static void shouldMakeCallout_WhenQueueableWithCallout() {
+    // Given
+    Test.setMock(HttpCalloutMock.class, new MockHttpResponse(200, '{"status":"ok"}'));
+    Account acc = TestDataFactory.createAccount(true);
+    
+    // When
+    Test.startTest();
+    MyQueueableWithCallout queueable = new MyQueueableWithCallout(acc.Id);
+    System.enqueueJob(queueable);
+    Test.stopTest();
+    
+    // Then
+    Account updated = [SELECT Id, External_Status__c FROM Account WHERE Id = :acc.Id];
+    System.assertEquals('Synced', updated.External_Status__c, 
+        'Should update status after successful callout');
+}
+```
+
+## Future Method Testing
+
+```apex
+@isTest
+static void shouldExecuteFutureMethod() {
+    // Given
+    Account acc = TestDataFactory.createAccount(true);
+    
+    // When
+    Test.startTest();
+    MyClass.processFuture(acc.Id); // @future method
+    Test.stopTest(); // Forces future to complete
+    
+    // Then
+    Account updated = [SELECT Id, Processed__c FROM Account WHERE Id = :acc.Id];
+    System.assertEquals(true, updated.Processed__c, 'Future should process record');
+}
+```
+
+## Scheduled Apex Testing
+
+### Testing Scheduled Execution
+
+```apex
+@isTest
+static void shouldExecuteScheduledJob() {
+    // Given
+    List<Account> accounts = TestDataFactory.createAccounts(50, true);
+    
+    // When
+    Test.startTest();
+    String cronExp = '0 0 0 1 1 ? 2099'; // Arbitrary future time
+    String jobId = System.schedule('Test Job', cronExp, new MyScheduledClass());
+    
+    // Execute the scheduled job immediately
+    MyScheduledClass scheduled = new MyScheduledClass();
+    scheduled.execute(null); // Pass null SchedulableContext in tests
+    Test.stopTest();
+    
+    // Then
+    List<Account> processed = [SELECT Id FROM Account WHERE Processed__c = true];
+    System.assertEquals(50, processed.size(), 'Scheduled job should process records');
+}
+```
+
+### Testing Schedule Registration
+
+```apex
+@isTest
+static void shouldScheduleJob() {
+    Test.startTest();
+    String cronExp = '0 0 6 * * ?'; // Daily at 6 AM
+    String jobId = System.schedule('Daily Processing', cronExp, new MyScheduledClass());
+    Test.stopTest();
+    
+    // Verify job is scheduled
+    CronTrigger ct = [
+        SELECT Id, CronExpression, State 
+        FROM CronTrigger 
+        WHERE Id = :jobId
+    ];
+    System.assertEquals('0 0 6 * * ?', ct.CronExpression, 'CRON should match');
+    System.assertEquals('WAITING', ct.State, 'Job should be waiting');
+}
+```
+
+## Testing Async Limits
+
+```apex
+@isTest
+static void shouldNotExceedQueueableLimits() {
+    // Given: Setup that might enqueue multiple jobs
+    List<Account> accounts = TestDataFactory.createAccounts(100, true);
+    
+    Test.startTest();
+    Integer queueablesBefore = Limits.getQueueableJobs();
+    
+    MyService.processWithQueueables(accounts);
+    
+    Integer queueablesUsed = Limits.getQueueableJobs() - queueablesBefore;
+    Test.stopTest();
+    
+    // Verify limit not exceeded (50 in synchronous context, 1 in queueable)
+    System.assert(queueablesUsed <= 50, 
+        'Should not exceed queueable limit. Used: ' + queueablesUsed);
+}
+```
+
+## Common Pitfalls
+
+### ❌ Forgetting Test.stopTest()
+
+```apex
+// Bad: Async never executes
+Test.startTest();
+System.enqueueJob(new MyQueueable());
+// Missing Test.stopTest()!
+
+List<Account> results = [SELECT Id FROM Account WHERE Processed__c = true];
+System.assertEquals(100, results.size()); // FAILS - queueable didn't run
+```
+
+### ❌ Testing chained jobs without understanding limits
+
+```apex
+// Only the FIRST chained queueable runs in tests
+// Design tests to verify:
+// 1. First job completes correctly
+// 2. Chain is properly enqueued (check AsyncApexJob)
+// 3. Each job works independently
+```
+
+### ❌ Not mocking callouts in async
+
+```apex
+// Async with callouts MUST have mock set BEFORE Test.startTest()
+Test.setMock(HttpCalloutMock.class, new MockResponse()); // Before startTest!
+Test.startTest();
+System.enqueueJob(new QueueableWithCallout());
+Test.stopTest();
+```