apex-test

/apex-test

Create a new Apex test class, or improve coverage for an existing one, following Salesforce best practices.

Usage

/apex-test MyClass.cls                  Find or create test class for MyClass
/apex-test --coverage MyClass.cls       Show current coverage + improve to 90%
/apex-test --coverage MyClass.cls 80%  Improve to specific target coverage level
/apex-test --bulk MyClass.cls          Focus on bulk (200+ record) test scenarios
/apex-test --mock MyClass.cls          Add HttpCalloutMock for all callout methods

---

Workflow

Step 1: Identify Target Class

• If a file path or class name is given, use that
• If none given, check git diff --name-only HEAD for changed .cls files (non-test)
• If no changed files, ask: "Which class would you like me to write tests for?"

Step 2: Read Source + Find Existing Tests

1. Read the source class fully — understand all public methods, logic branches, error paths
2. Search for existing test class: <ClassName>Test.cls in force-app/**/classes/
3. If test class exists: read it and identify untested paths
4. If no test class: create from scratch

Step 3: Analyze Coverage Gaps

For each public method in the source class:

• Identify: happy path, bulk path (200 records), null/empty input, negative/error path
• Check existing tests — which paths are already covered?
• For --coverage: note current % and identify the highest-impact untested lines

Step 4: Generate / Improve Tests

Test class standards:

@isTest
private class AccountServiceTest {

    @TestSetup
    static void setup() {
        // Always use TestDataFactory for test data — never inline record creation
        List<Account> accounts = TestDataFactory.createAccounts(200, 'Test Corp');
        insert accounts;
    }

    @isTest
    static void testProcessAccounts_happyPath() {
        List<Account> accounts = [SELECT Id, Industry FROM Account LIMIT 10];
        
        Test.startTest();
        AccountService.processAccounts(new Map<Id, Account>(accounts).keySet());
        Test.stopTest();
        
        // Assert expected outcome
        List<Account> updated = [SELECT Id, Status__c FROM Account WHERE Id IN :accounts];
        for (Account acc : updated) {
            Assert.areEqual('Active', acc.Status__c, 'Status should be Active after processing');
        }
    }

    @isTest
    static void testProcessAccounts_bulk() {
        // Bulk test — always test with 200 records
        List<Account> accounts = [SELECT Id FROM Account]; // setup created 200
        Assert.areEqual(200, accounts.size(), 'Setup should create 200 accounts');
        
        Test.startTest();
        AccountService.processAccounts(new Map<Id, Account>(accounts).keySet());
        Test.stopTest();
        
        // Verify all 200 processed
        Integer processed = [SELECT COUNT() FROM Account WHERE Status__c = 'Active'];
        Assert.areEqual(200, processed, 'All 200 accounts should be processed');
    }

    @isTest
    static void testProcessAccounts_emptyInput() {
        Test.startTest();
        AccountService.processAccounts(new Set<Id>()); // Should not throw
        Test.stopTest();
        // No exception = pass
    }

    @isTest
    static void testProcessAccounts_nullInput() {
        Test.startTest();
        try {
            AccountService.processAccounts(null);
            Assert.fail('Should throw for null input');
        } catch (IllegalArgumentException e) {
            Assert.isTrue(e.getMessage().contains('null'), 'Error message should mention null');
        }
        Test.stopTest();
    }
}