@salesforce/afv-skills 1.1.0 → 1.2.0

package/skills/apex-class/templates/utility.cls

@@ -1,97 +0,0 @@
-/**
- * @description Utility class for {describe the category of utilities: String, Date, Collection, etc.}.
- *              All methods are static and side-effect-free (no SOQL, no DML).
- *              Private constructor prevents instantiation.
- * @author Generated by Apex Class Writer Skill
- */
-public with sharing class {ClassName} {
-
-    // ─── Private Constructor ─────────────────────────────────────────────
-
-    /**
-     * @description Prevents instantiation — use static methods only
-     */
-    @TestVisible
-    private {ClassName}() {
-        // Utility class — do not instantiate
-    }
-
-    // ─── Public Methods ──────────────────────────────────────────────────
-
-    // TODO: Add utility methods below. Examples:
-
-    /**
-     * @description Safely converts a String to an Integer, returning a default if parsing fails
-     * @param value The String to parse
-     * @param defaultValue The fallback value if parsing fails
-     * @return The parsed Integer or the default value
-     * @example
-     * Integer result = {ClassName}.safeParseInteger('42', 0); // returns 42
-     * Integer result = {ClassName}.safeParseInteger('abc', 0); // returns 0
-     */
-    public static Integer safeParseInteger(String value, Integer defaultValue) {
-        if (String.isBlank(value)) {
-            return defaultValue;
-        }
-        try {
-            return Integer.valueOf(value.trim());
-        } catch (TypeException e) {
-            return defaultValue;
-        }
-    }
-
-    /**
-     * @description Chunks a list into smaller sublists of the specified size.
-     *              Useful for processing records in governor-limit-safe batches.
-     * @param items The list to chunk
-     * @param chunkSize The maximum size of each chunk
-     * @return A list of sublists, each containing up to chunkSize elements
-     * @example
-     * List<List<String>> chunks = {ClassName}.chunkList(myList, 200);
-     */
-    public static List<List<Object>> chunkList(List<Object> items, Integer chunkSize) {
-        List<List<Object>> chunks = new List<List<Object>>();
-        if (items == null || items.isEmpty() || chunkSize <= 0) {
-            return chunks;
-        }
-
-        List<Object> currentChunk = new List<Object>();
-        for (Object item : items) {
-            currentChunk.add(item);
-            if (currentChunk.size() == chunkSize) {
-                chunks.add(currentChunk);
-                currentChunk = new List<Object>();
-            }
-        }
-
-        if (!currentChunk.isEmpty()) {
-            chunks.add(currentChunk);
-        }
-
-        return chunks;
-    }
-
-    /**
-     * @description Extracts a Set of non-null field values from a list of SObjects
-     * @param records The SObject records to extract from
-     * @param fieldName The API name of the field to extract
-     * @return A Set of non-null String values
-     * @example
-     * Set<String> emails = {ClassName}.pluckStrings(contacts, 'Email');
-     */
-    public static Set<String> pluckStrings(List<SObject> records, String fieldName) {
-        Set<String> values = new Set<String>();
-        if (records == null || String.isBlank(fieldName)) {
-            return values;
-        }
-
-        for (SObject record : records) {
-            Object val = record.get(fieldName);
-            if (val != null) {
-                values.add(String.valueOf(val));
-            }
-        }
-
-        return values;
-    }
-}

package/skills/apex-test-class/SKILL.md

@@ -1,101 +0,0 @@
----
-name: apex-test-class
-description: Apex test class generation with TestDataFactory patterns, bulk testing (200+ records), mocking strategies for callouts and async operations, and assertion best practices. Use when creating new Apex test classes, improving test coverage, refactoring existing tests, or implementing proper testing patterns for triggers, services, controllers, batch jobs, queueables, and integrations.
----
-
-# Apex Test Class Skill
-
-## Core Principles
-
-1. **Bulkify tests** - Always test with 200+ records to catch governor limit issues
-2. **Isolate test data** - Use `@TestSetup` and TestDataFactory; never rely on org data
-3. **Assert meaningfully** - Test behavior, not just coverage; include failure messages
-4. **Mock external dependencies** - Use `HttpCalloutMock`, `Test.setMock()` for integrations
-5. **Test negative paths** - Validate error handling, not just happy paths
-
-## Test Class Structure
-
-```apex
-@IsTest
-private class MyServiceTest {
-
-    @TestSetup
-    static void setupTestData() {
-        // Create shared test data using TestDataFactory
-        List<Account> accounts = TestDataFactory.createAccounts(200, true);
-    }
-
-    @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();
-        MyService.processAccounts(accounts);
-        Test.stopTest();
-        
-        // Then: Assert expected outcomes
-        List<Account> updated = [SELECT Id, Status__c FROM Account];
-        System.Assert.areEqual(200, updated.size(), 'All accounts should be processed');
-        for (Account acc : updated) {
-            System.Assert.areEqual('Processed', acc.Status__c, 'Status should be updated');
-        }
-    }
-
-    @IsTest
-    static void shouldThrowException_WhenInvalidInput() {
-        // Given
-        List<Account> emptyList = new List<Account>();
-        
-        // When/Then
-        Test.startTest();
-        try {
-            MyService.processAccounts(emptyList);
-            System.Assert.fail('Expected MyCustomException to be thrown');
-        } catch (MyCustomException e) {
-            System.Assert.isTrue(e.getMessage().contains('cannot be empty'), 
-                'Exception message should indicate empty input');
-        }
-        Test.stopTest();
-    }
-}
-```
-
-## Naming Convention
-
-Use descriptive method names: `should[ExpectedBehavior]_When[Condition]`
-
-Examples:
-- `shouldCreateContact_WhenAccountIsActive`
-- `shouldThrowException_WhenEmailIsInvalid`
-- `shouldSendNotification_WhenOpportunityClosedWon`
-- `shouldBypassTrigger_WhenRunningAsBatch`
-
-## Test.startTest() / Test.stopTest()
-
-Always wrap the code under test:
-- Resets governor limits for accurate limit testing
-- Executes async operations synchronously (queueables, batch, future)
-- Fires scheduled jobs immediately
-
-## Reference Files
-
-Detailed patterns for specific scenarios:
-
-- **[references/test-data-factory.md](references/test-data-factory.md)** - TestDataFactory class patterns and field defaults
-- **[references/assertion-patterns.md](references/assertion-patterns.md)** - Assertion best practices and common pitfalls
-- **[references/mocking-patterns.md](references/mocking-patterns.md)** - HttpCalloutMock, Test.setMock(), stubbing
-- **[references/async-testing.md](references/async-testing.md)** - Batch, Queueable, Future, Scheduled job testing
-
-## Quick Reference: What to Test
-
-| Component | Key Test Scenarios |
-|-----------|-------------------|
-| Trigger | Bulk insert/update/delete, recursion, field changes |
-| Service | Valid/invalid inputs, bulk operations, exceptions |
-| Controller | Page load, action methods, view state |
-| Batch | Start/execute/finish, chunking, error records |
-| Queueable | Chaining, bulkification, error handling |
-| Callout | Success response, error response, timeout |
-| Scheduled | Execution, CRON validation |

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

@@ -1,209 +0,0 @@
-# Assertion Patterns
-
-## Assertion Methods
-
-The `System.Assert` class provides methods to assert various conditions in test methods. All methods support an optional message parameter for better error reporting.
-
-| Method | Use Case |
-|--------|----------|
-| `System.Assert.areEqual(expected, actual, msg)` | Exact equality |
-| `System.Assert.areNotEqual(notExpected, actual, msg)` | Value should differ |
-| `System.Assert.isTrue(condition, msg)` | Boolean condition is true |
-| `System.Assert.isFalse(condition, msg)` | Boolean condition is false |
-| `System.Assert.isNull(value, msg)` | Value is null |
-| `System.Assert.isNotNull(value, msg)` | Value is not null |
-| `System.Assert.isInstanceOfType(instance, expectedType, msg)` | Instance is of specified type |
-| `System.Assert.isNotInstanceOfType(instance, notExpectedType, msg)` | Instance is not of specified type |
-| `System.Assert.fail(msg)` | Explicitly fail the test |
-
-**Always include the message parameter** - Makes test failures meaningful and easier to debug.
-
-**Note:** Assertion failures are fatal errors that halt code execution. You cannot catch assertion failures using try/catch blocks, even though they're logged as exceptions.
-
-
-**Note:** Call `startTest()` and `stopTest()` only once per test method. Wrap only the code under test between these calls, not setup or verification code.
-
-## Good vs Bad Assertions
-
-### ❌ Bad: No message, tests coverage not behavior
-
-```apex
-System.Assert.areEqual(true, result);
-System.Assert.isTrue(accounts.size() > 0);
-```
-
-### ✅ Good: Descriptive message, tests specific behavior
-
-```apex
-System.Assert.areEqual(true, result, 'Service should return true for valid input');
-System.Assert.areEqual(200, accounts.size(), 'All 200 accounts should be processed');
-```
-
-## Common Assertion Patterns
-
-### Collection Size
-
-```apex
-// Exact count
-System.Assert.areEqual(200, results.size(), 'Should process all 200 records');
-
-// Not empty
-System.Assert.isFalse(results.isEmpty(), 'Results should not be empty');
-
-// Empty
-System.Assert.isTrue(results.isEmpty(), 'No results expected for invalid input');
-```
-
-### Field Values
-
-```apex
-// Single record
-System.Assert.areEqual('Processed', acc.Status__c, 'Account status should be updated to Processed');
-
-// All records in collection
-for (Account acc : updatedAccounts) {
-    System.Assert.areEqual('Active', acc.Status__c, 
-        'Account ' + acc.Name + ' should have Active status');
-}
-```
-
-### Exception Testing
-
-```apex
-@IsTest
-private 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.isTrue(exceptionThrown, 'MyCustomException should be thrown for null input');
-    System.Assert.isTrue(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.isTrue(sr.isSuccess(), 'Insert should succeed: ' + sr.getErrors());
-}
-
-// Expected failures
-Database.SaveResult sr = Database.insert(invalidAccount, false);
-System.Assert.isFalse(sr.isSuccess(), 'Insert should fail for invalid data');
-System.Assert.isTrue(sr.getErrors()[0].getMessage().contains('REQUIRED_FIELD_MISSING'),
-    'Error should indicate missing required field');
-```
-
-### Comparing Objects
-
-```apex
-// Compare specific fields, not entire objects
-System.Assert.areEqual(expected.Name, actual.Name, 'Names should match');
-System.Assert.areEqual(expected.Status__c, actual.Status__c, 'Status should match');
-
-// Or use JSON for deep comparison (use sparingly)
-System.Assert.areEqual(
-    JSON.serialize(expected), 
-    JSON.serialize(actual), 
-    'Objects should be identical'
-);
-```
-
-### Date/DateTime Assertions
-
-```apex
-// Exact date
-System.Assert.areEqual(Date.today(), record.CreatedDate__c, 'Should be created today');
-
-// Date within range
-System.Assert.isTrue(record.DueDate__c >= Date.today(), 'Due date should be in the future');
-System.Assert.isTrue(record.DueDate__c <= Date.today().addDays(30), 
-    'Due date should be within 30 days');
-```
-
-### Null Checks
-
-```apex
-// Should be null
-System.Assert.isNull(result.ErrorMessage__c, 'No error expected for valid input');
-
-// Should not be null
-System.Assert.isNotNull(result.Id, 'Record should have been inserted');
-```
-
-### Type Checking
-
-```apex
-// Verify instance is of expected type
-Object result = MyService.processData();
-System.Assert.isInstanceOfType(result, MyCustomClass.class, 
-    'Result should be an instance of MyCustomClass');
-
-// Verify instance is not of a specific type
-Object handler = HandlerFactory.create('Account');
-System.Assert.isNotInstanceOfType(handler, ContactHandler.class, 
-    'Account handler should not be a ContactHandler');
-```
-
-### Explicit Test Failures
-
-```apex
-// Use Assert.fail() when an exception should have been thrown but wasn't
-@IsTest
-private static void shouldThrowException_WhenInputInvalid() {
-    try {
-        MyService.process(null);
-        System.Assert.fail('Expected MyCustomException to be thrown for null input');
-    } catch (MyCustomException e) {
-        // Exception was thrown as expected, test passes
-        System.Assert.isTrue(e.getMessage().contains('cannot be null'), 
-            'Exception message should mention null input');
-    }
-}
-```
-
-## Anti-Patterns to Avoid
-
-### ❌ Testing implementation, not behavior
-
-```apex
-// Bad: Testing that a specific method was called
-System.Assert.isTrue(MyClass.methodWasCalled, 'Method should be called');
-
-// Good: Testing the observable outcome
-System.Assert.areEqual('Expected Value', record.Field__c, 'Field should be updated');
-```
-
-### ❌ Overly generic assertions
-
-```apex
-// Bad: Passes for any non-empty result
-System.Assert.isTrue(results.size() > 0);
-
-// Good: Verifies exact expected count
-System.Assert.areEqual(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.Assert.areEqual('Success', r.status, 'Processing should succeed');
-System.Assert.areEqual(0, r.errorCount, 'No errors should occur');
-```

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

@@ -1,276 +0,0 @@
-# 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
-private 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.Assert.areEqual('Processed', acc.Status__c, 
-            'Batch should update all account statuses');
-    }
-}
-```
-
-### Testing Batch with Failures
-
-```apex
-@IsTest
-private 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.Assert.areEqual(2, errors.size(), 'Should log 2 failed records');
-}
-```
-
-### Testing Batch Scope
-
-```apex
-@IsTest
-private 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.Assert.areEqual(250, processed.size(), 'All records should be processed');
-}
-```
-
-## Queueable Testing
-
-### Basic Queueable Test
-
-```apex
-@IsTest
-private 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.Assert.areEqual('Processed', updated.Status__c, 
-        'Queueable should update account status');
-}
-```
-
-### Testing Queueable Chaining
-
-Chained queueables only execute the first job in tests:
-
-```apex
-@IsTest
-private 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.Assert.areEqual(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.isTrue(jobs.size() >= 1, 'Chained job should be enqueued');
-}
-```
-
-### Testing Queueable with Callouts
-
-```apex
-@IsTest
-private 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.Assert.areEqual('Synced', updated.External_Status__c, 
-        'Should update status after successful callout');
-}
-```
-
-## Future Method Testing
-
-```apex
-@IsTest
-private 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.Assert.areEqual(true, updated.Processed__c, 'Future should process record');
-}
-```
-
-## Scheduled Apex Testing
-
-### Testing Scheduled Execution
-
-```apex
-@IsTest
-private 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.Assert.areEqual(50, processed.size(), 'Scheduled job should process records');
-}
-```
-
-### Testing Schedule Registration
-
-```apex
-@IsTest
-private 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.Assert.areEqual('0 0 6 * * ?', ct.CronExpression, 'CRON should match');
-    System.Assert.areEqual('WAITING', ct.State, 'Job should be waiting');
-}
-```
-
-## Testing Async Limits
-
-```apex
-@IsTest
-private 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.isTrue(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.Assert.areEqual(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();
-```