Retrieve Trigger.newMap Values In After Update Context

Question

I have the following Trigger, Class & Unit Test

trigger WE_MasterOpportunityTrigger on Opportunity (
    before insert, after insert, 
    before update, after update, 
    before delete, after delete)
{    
    if (Trigger.IsAfter) {
        if (Trigger.isInsert) {
            // class needs to execute in After context so that values are still populated when 
            // an Opportunity is created through Lead conversion
            WE_OppUpdates oppPreparation = new WE_OppUpdates(Trigger.oldMap, Trigger.newMap);
            oppPreparation.updateOpportunities();
        } 
        if (Trigger.isUpdate) {
            WE_OppUpdates oppPreparation = new WE_OppUpdates(Trigger.oldMap,Trigger.newMap);
            oppPreparation.updateOpportunities();
        }
    }
}

---

public class WE_OppUpdates {

    // variables
    Map<Id, Opportunity> oldOpps;
    Map<Id, Opportunity> newOpps;
    Date cd;
    Opportunity oldOpp;
    List<Opportunity> oppsToUpdate = new List<Opportunity>();

    // constructor
    public WE_OppUpdates(
        Map<Id, Opportunity> oldTriggerOpps, 
        Map<Id, Opportunity> newTriggerOpps) {
            oldOpps = oldTriggerOpps;
            newOpps = newTriggerOpps;
        }

    public void updateOpportunities() {

                if (Trigger.isInsert){

                    List<Opportunity> insertedOpps = [SELECT Id, CloseDate, Ramp_Profile__c FROM Opportunity
                                                       WHERE Id IN :newOpps.keySet()];

                    for (Opportunity o : insertedOpps){

                            cd = o.CloseDate;

                            if (o.Ramp_Profile__c == 'Immediate'){
                                o.Implementation_Revenue__c = cd.addDays(15);
                                o.Revenue_Commencement__c = o.Implementation_Revenue__c.addMonths(1).toStartOfMonth();
                                // etc
                            } else if (o.Ramp_Profile__c == 'Standard'){
                                // set different values 
                            } 
                    }
                    update oppsToUpdate;
                }

                if (Trigger.isUpdate){

                    List<Opportunity> updatedOpps = [SELECT Id, RecordTypeId, CloseDate, Ramp_Profile__c FROM Opportunity
                                                      WHERE Id IN :newOpps.keySet()];

                    for (Opportunity o : updatedOpps){

                            cd = o.CloseDate;

                            Opportunity oldOpp = oldOpps.get(o.Id);

                            system.debug('oldOpp Ramp Profile is ' + oldOpp.Ramp_Profile__c);
                            system.debug('newOpp Ramp Profile is ' + o.Ramp_Profile__c);
                            system.debug('oldOpp Close Date is ' + oldOpp.CloseDate);
                            system.debug('newOpp Close Date is ' + o.CloseDate);

                            if (oldOpp.CloseDate != o.CloseDate
                                ||
                                oldOpp.Ramp_Profile__c != o.Ramp_Profile__c){
                                    if (o.Ramp_Profile__c == 'Immediate'){
                                        o.Implementation_Revenue__c = cd.addDays(15);
                                        }
                                        oppsToUpdate.add(o);

                                    } else if (o.Ramp_Profile__c == 'Medium'){
                                        // set different values
                                    }
                            } 
                    }
                    update oppsToUpdate;
    }
}

---

@isTest
public class WE_OppUpdatesTest{

    @testSetup
    static void dataSetup() {

            List<Opportunity> opportunities1 = WE_TestDataUtility.createOpportunities(
                25,                                 // noOpps
                '<*>',                              // identifier
                date.today().addMonths(1),          // closeDate
                'Standard');                        // rampProfile

            insert Opportunities1;
    }

    static testMethod void testOppUpdates(){

        List <Opportunity> opportunities = [SELECT Id,RecordTypeId,Name,CloseDate,Ramp_Profile__c FROM Opportunity WHERE Name LIKE '%<*>%'];

        Test.startTest();

        for(Opportunity o : opportunities){
            o.CloseDate = o.CloseDate.addmonths(1);
            o.Ramp_Profile__c = 'Immediate';

        }
        update opportunities;
        Test.stopTest();
    }
}

When I run the test my debug lines in the isUpdate section show that the values for the Ramp_Profile__c & CloseDate fields are unchanged.

My understanding is that the two maps should contain the old & new values so perhaps I'm not passing the values through to my Class correctly or is this issue occurring because of my SOQL query or something else?

Answer 1

Here's how you can change your after-update trigger to a before-update trigger:

public class WE_OppUpdates {
    static Boolean recursiveUpdate = false;
    public static void recursiveInsert(Opportunity[] records) {
        recursiveUpdate = true;
        update records.deepClone(true);
    }
    public static void updateOpportunities(Opportunity[] oldRecords, Opportunity[] newRecords) {
        for(Integer index = 0, size = newRecords.size(); index < size; index++) {
            Opportunity oldRecord = oldRecords[index], newRecord = newRecords[index];
            if(recursiveUpdate || 
               oldRecord.CloseDate != newRecord.CloseDate || 
               oldRecord.Ramp_Profile__c != newRecord.Ramp_Profile__c) {
                   if(newRecord.Ramp_Profile__c == 'Immediate') {
                       // ...
                   } else if(newRecord.Ramp_Profile__c == 'Medium') {
                       // ...
                   }
            }
        }
    }
}

And, of course, change your trigger as appropriate:

if(Trigger.isInsert && Trigger.isAfter) WE_OppUpdates.recursiveInsert(Trigger.new);
if(Trigger.isUpdate && Trigger.isBefore) WE_Updates.updateOpportunities(Trigger.old, Trigger.new);

After that, you'll find your code is easier to test, and recursion is a lot easier to control.

Answer 2

From looking at your code, it appears to me that when you insert new records in your test class, your trigger fires causing an update of Opportunity.

            if (Trigger.isInsert){

                ....

                for (Opportunity o : insertedOpps){

                        .....

                        } else if (o.Ramp_Profile__c == 'Standard'){
                            // set different values 
                        } 
                }
     // ==>     update oppsToUpdate;

When the above happens, this causes the trigger to fire again in the same execution context. Unless you add a boolean flag of some kind to prevent it, the trigger will fire again and do an after update in this execution context. When that happens, you'll see the same trigger.oldas existed the first time the trigger fired in the AfterInsert context.

This happens before you ever do the update in your test class and may be what you're seeing in your debug logs. This same recursion will occur in your AfterUpdate handler code if you don't do something to prevent it.

More than anything, I recommend you add debug statements in your test class to obtain the values of your important variables after insertion of Opportunities1 and following your query to get list opportunities. You'll also benefit from inserting debug statements in your code after update opportunities; (can be placed after Test.stopTest(); if you prefer).

Once you have things sorted, your class should include assertions of what you expect those values to be instead of the debug statements following Test.stopTest();