How to handle newMap and oldMap in Trigger Handlers for both insert and update Triggers

Question

I have a general question about comparing newMap values with oldMap values in an Apex Class made for both update and insert contexts.

Let's say we have an Account Handler method that must run when an Account Name is changed or the Account is created.

When testing the below code for an update context everything will work fine since we're able to compare Trigger.oldMap with Trigger.newMap.

public class exampleAccountHandler {

public static void exampleAccountMethod (Map<Id, Account> accountListNew, Map<Id, Account> accountListOld) {




        // Code





        for (Account myAccount : accountListNew.values()) {

            if (accountListNew.get(myAccount.Id).Name != accountListOld.get(myAccount.Id).Name) {

                 // Logic

            }
        }
    }
}

In the Account Master Trigger it will look somewhat like this:

if (Trigger.isBefore)

if (Trigger.isUpdate) {

    exampleAccountHandler.exampleAccountMethod(Trigger.oldMap, Trigger.newMap);

}

When we're testing the same for an insert context it will throw a null pointer exception error since we don't have anything to compare on the oldMap side (it will run the if clause where the oldMap is referenced). Also, Trigger.oldMap cannot be used in the insert context.

What are the best practices to circumvent this issue? Define a separate method for the insert context (I assume there can only be Trigger.newMap as an input)? Adding logic to the Trigger (I guess no)? Something in between?

Looking forward to your help!

Answer 1

This example highlights a common programming anti-pattern. The only reason you are having difficulty here is that you have conflated your filter and your action. You should instead have two methods here: one which filters only records whose name has changed, and one which manipulates all records on which you should act. Basically:

public with sharing class AccountService
{
    public static List<Account> hasNameChanged(List<Account> newRecords, Map<Id, Account> oldMap)
    {
        List<Account> output = new List<Account>();
        for (Account record : newRecords)
        {
            if (record.Name != oldMap.get(record.Id).Name)
            {
                output.add(record);
            }
        }
        return output;
    }
    public static void doStuff(List<Account> records)
    {
        // put your ACTION here
        // only pass in records on which you should act
    }
}

Then in your trigger handler, you should have some code like:

public void beforeInsert()
{
    AccountService.doStuff(newRecords);
}
public void beforeUpdate()
{
    AccountService.doStuff(AccountService.hasNameChanged(newRecords, oldMap));
}

In addition to simplifying your trigger handler, this pattern greatly simplifies unit testing. Now, when testing your action, data setup is much simpler. You can pass in any collection of records and they should be treated the same. Also, when verifying if your filter works correctly, you can simply check how many records you get back. This pattern should be used for every trigger action and filter, regardless of what events it fires on.