Sf Test

# Apex Test Patterns Reference

Complete, compilable code examples for every major Apex test pattern.

---

## 1. Testing @future Methods

`@future` methods execute asynchronously. In tests, they run synchronously between `Test.startTest()` and `Test.stopTest()`.

```apex
public class AccountProcessor {
    @future
    public static void updateAccountRating(Set<Id> accountIds) {
        List<Account> accounts = [SELECT Id, Rating FROM Account WHERE Id IN :accountIds];
        for (Account a : accounts) {
            a.Rating = 'Hot';
        }
        update accounts;
    }
}

@IsTest
private class AccountProcessorTest {
    @IsTest
    static void testUpdateAccountRating() {
        Account acc = new Account(Name = 'Test Account', Rating = 'Cold');
        insert acc;

        Test.startTest();
        AccountProcessor.updateAccountRating(new Set<Id>{ acc.Id });
        Test.stopTest();
        // @future method has now completed

        Account updated = [SELECT Rating FROM Account WHERE Id = :acc.Id];
        Assert.areEqual('Hot', updated.Rating, 'Rating should be updated to Hot');
    }
}
```

---

## 2. Testing Batch Apex

Batch jobs run between `Test.startTest()` and `Test.stopTest()`. In test context, `execute()` receives at most 200 records regardless of scope size. Only one `Database.executeBatch` call is allowed per test method.

```apex
public class AccountCleanupBatch implements Database.Batchable<SObject> {
    public Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator('SELECT Id, Description FROM Account WHERE Description = null');
    }

    public void execute(Database.BatchableContext bc, List<Account> scope) {
        for (Account a : scope) {
            a.Description = 'Cleaned by batch';
        }
        update scope;
    }

    public void finish(Database.BatchableContext bc) {
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        mail.setToAddresses(new String[]{ 'admin@example.com' });
        mail.setSubject('Batch Complete');
        mail.setPlainTextBody('Account cleanup finished.');
        Messaging.sendEmail(new Messaging.SingleEmailMessage[]{ mail });
    }
}

@IsTest
private class AccountCleanupBatchTest {
    @TestSetup
    static void setup() {
        List<Account> accounts = new List<Account>();
        for (Integer i = 0; i < 50; i++) {
            accounts.add(new Account(Name = 'Test ' + i));
        }
        insert accounts;
    }

    @IsTest
    static void testBatchExecution() {
        Test.startTest();
        Id batchId = Database.executeBatch(new AccountCleanupBatch(), 200);
        Test.stopTest();
        // Batch has completed — start, execute, finish all ran

        List<Account> updated = [SELECT Description FROM Account];
        for (Account a : updated) {
            Assert.areEqual('Cleaned by batch', a.Description, 'Description should be set by batch');
        }

        // Verify the batch job completed
        AsyncApexJob job = [
            SELECT Status, NumberOfErrors, JobItemsProcessed, TotalJobItems
            FROM AsyncApexJob
            WHERE Id = :batchId
        ];
        Assert.areEqual('Completed', job.Status);
        Assert.areEqual(0, job.NumberOfErrors);
    }
}
```

---

## 3. Testing Queueable Apex

Queueable jobs execute synchronously between `Test.startTest()` and `Test.stopTest()`. In test context, chaining is limited to depth 1 (a queueable can enqueue at most one additional queueable).

```apex
public class AccountEnrichmentQueueable implements Queueable {
    private List<Id> accountIds;

    public AccountEnrichmentQueueable(List<Id> accountIds) {
        this.accountIds = accountIds;
    }

    public void execute(QueueableContext context) {
        List<Account> accounts = [SELECT Id, Industry FROM Account WHERE Id IN :accountIds];
        for (Account a : accounts) {
            a.Industry = 'Technology';
        }
        update accounts;

        //