[SalesForce] Apex Trigger catch block can’t be covered by test class

I have a trigger named AssignsCanadaWebLeadtoQueueOnLanguage on our Stage instance which according to Developer Console has lines within a catch block which I can't seem to cover using my test class named TestAssignsCaWebLeadtoQueueOnLanguage.

I specifically tried to test the exception within the AssignsCanadaWebLeadtoQueueOnLanguage_Exception_Test method within my test class. I've tried throwing a new custom Exception. I've tried creating an Exception scenario by creating a Lead and then inserting it without setting any required field values.

However, I can't seem to get these catch lines to be covered by this method. I read that there is the possibility of lines that can't be covered at all.

Is this one of those situations? If not, how can I move forward and get the lines within my catch block for this trigger covered by my test class method?

trigger AssignsCanadaWebLeadtoQueueOnLanguage on Lead (before insert) 
{
    // Purpose: This trigger was written as part of a fix for an issue where multiple notification emails 
    //          were being sent to members of a particular queue after a Canada Web Lead was created. 
    //          Only one email was needed. 
    // This trigger is meant to replace two workflow rules:
    //          " - Assigns Web Lead to English Queue on Language" and
    //          "- Assigns Web Lead to French Queue on Language"
    try
    {
        string strEnglishQueue = Label.CanadianEnglishWebLeadQueue;
        string strFrenchQueue = Label.CanadianFrenchWebLeadQueue;

        User mqUser = [Select id from User where Alias = 'jaffa'];        
        Group gEnglish = [Select Id From Group where Name = :strEnglishQueue AND Type = 'Queue'];    
        Group gFrench = [Select Id From Group where Name = :strFrenchQueue AND Type = 'Queue'];

        for(Lead l : trigger.new) 
        {    

            // We only want to address Canada Web Leads.  These leads are defined as 
            // leads where the owner is the MQ Broker user
            if (l.OwnerID == mqUser.id) 
            {                
                l.LeadSource = Label.CanadianWebLeadSource;

                // Change Lead Owner to appropriate queue based on language
                if(l.LA_Language__c == 'English')
                {
                    l.OwnerID = gEnglish.id;
                }
                if(l.LA_Language__c == 'French')
                {
                    l.OwnerID = gFrench.id;                 
                }                                            
            }            
        }          
    }
    catch (Exception e)
    {
        String SourceRecords='Lead Id: ';
        for (Integer i=0; i < Trigger.size; i++)
        {
            SourceRecords = SourceRecords+';'+Trigger.new[i].Get('Id');
        }

        String HTMLEmailBody = 'A Web Lead has been created in Salesforce.com  with the following exception in the AssignsCanadaWebLeadtoQueueOnLanguage trigger:<br><br> ' +
        'Error: ' + e.getMessage() + ' <br><br>' + e.getStackTraceString() + ' <br><br>' +
        SourceRecords  + '</a>';

        String recipients = Label.CandaWebLeadsExceptionEmailList;
        String[] toAddresses = new String[]{};
        toAddresses = recipients.split(',');

        EmailAsync.sendEmailAsync(toAddresses,Label.CandaWebLeadsExceptionEmailList,'Salesforce Web Lead Exception',
        'A Web Lead has been created in Salesforce.com with an Exception',
        false, false,'A Web Lead has been created in Salesforce.com  with the following exception in the AssignsCanadaWebLeadtoQueueOnLanguage trigger',
        HTMLEmailBody);
    }                  
}

**************test class *****************

@isTest
private class TestAssignsCaWebLeadtoQueueOnLanguage 
{    
    static testMethod void AssignsCanadaWebLeadtoQueueOnLanguage_English_Test()
    {
        test.StartTest();
        Group newGroup = TestFactory.returnGroupbyName('Canada Web Leads - English');

        Campaign newCampaign = TestFactory.buildTestCampaign('TestCampaign');
        insert newCampaign;        

        User u = TestFactory.returnUserByAlias('tycoismq'); 

        System.runAs(u) 
        { 
            Lead newLead = TestFactory.buildTestLead(String.valueOf(newCampaign.Id),'English');
            insert newLead;

            Lead assertLead = TestFactory.returnLeadById(newLead.Id); 

            // Ensure correct LeadSource as assigned by the AssignsCanadaWebLeadtoQueueOnLanguage trigger
            System.assertEquals(assertLead.LeadSource,Label.CanadianWebLeadSource);

            // Ensure Canadian Web Lead English queue was assigned this Lead by 
            // the AssignsCanadaWebLeadtoQueueOnLanguage trigger
            System.assertEquals(assertLead.OwnerId, newGroup.Id);                                   
        }
        test.StopTest();        
    }

    static testMethod void AssignsCanadaWebLeadtoQueueOnLanguage_French_Test()
    {
        test.StartTest();
        Group newGroup = TestFactory.returnGroupbyName('Canada Web Leads - French');

        Campaign newCampaign = TestFactory.buildTestCampaign('TestCampaign');
        insert newCampaign;

        User u = TestFactory.returnUserByAlias('jaffa'); 

        System.runAs(u) 
        { 
            Lead newLead = TestFactory.buildTestLead(String.valueOf(newCampaign.Id),'French');
            insert newLead;

            System.debug('################# newLead: ' + newLead );
            Lead assertLead = TestFactory.returnLeadById(newLead.Id); 
            System.assertEquals(assertLead.OwnerId, newGroup.Id);
            System.assertEquals(assertLead.LeadSource,Label.CanadianWebLeadSource);            
        }
        test.StopTest();        
    }


    static testMethod void AssignsCanadaWebLeadtoQueueOnLanguage_Negative_Test()
    {
        test.StartTest();
        Group newGroup = TestFactory.returnGroupbyName('Canada Web Leads - English');

        Campaign newCampaign = TestFactory.buildTestCampaign('TestCampaign');
        insert newCampaign;

        User u = TestFactory.returnUserByAlias('gvale'); 

        System.runAs(u) 
        { 
            Lead newLead = TestFactory.buildTestLead(String.valueOf(newCampaign.Id),'English');
            insert newLead;

            System.debug('################# newLead: ' + newLead );
            Lead assertLead = TestFactory.returnLeadById(newLead.Id); 
            System.assertEquals(assertLead.OwnerId, u.Id);
            System.assertNotEquals(assertLead.LeadSource,Label.CanadianWebLeadSource);
        }
        test.StopTest();        
    }    

    static testMethod void AssignsCanadaWebLeadtoQueueOnLanguage_Exception_Test()
    {
        test.StartTest();
        Group newGroup = TestFactory.returnGroupbyName('Canada Web Leads - French');

        Campaign newCampaign = TestFactory.buildTestCampaign('TestCampaign');
        insert newCampaign;

        User u = TestFactory.returnUserByAlias('jaffa'); 

        System.runAs(u) 
        { 
            try
            {
                Lead newLead;                
                insert newLead;
                throw new customException('An exception should have been thrown by the trigger but was not.');
            }
            catch(NullPointerException e)
            {
                //throw new customException('threw exception to trigger');
                Boolean expectedExceptionThrown =  e.getMessage().contains('de-reference a null') ? true : false;
                System.AssertEquals(expectedExceptionThrown, true);          
            }                                       
        }
        test.StopTest();        
    }        
}

Best Answer

To get the catch block to execute, an exception would need to originate from the try block of code in the trigger. If your trigger was doing an update, some validation elsewhere might result in a DMLException being thrown and sometimes you might choose to catch and handle that. But the other source of exceptions is essentially programming errors and the best approach there is to eliminate those errors by improving the logic (and sometimes adding checks for null to avoid the errors).

But if you want to keep the try/catch block and get test coverage on it, you need to figure out some way of setting up the data in your test so that one of the 3 queries fails (e.g. returns no rows).

(That you are using System.runAs suggests that the trigger should be using UserInfo.getUserId() rather than always querying the "jaffa" user.)

Sample Code: Original

trigger updateAccounts on Contact (after insert) {
    Map<Id, Account> accounts = new Map<Id, Account>();
    for(Contact record: Trigger.new)
        accounts.put(record.AccountId, null);
    accounts.remove(null);
    accounts.putAll([SELECT Id,Count_Contact__c FROM Account WHERE Id IN :accounts.keySet()]);
    for(Account record: accounts.values())
        if(record.Count_Contact__c == null)
            record.Count_Contact__c = 0;
    for(Contact record: Trigger.new)
        if(accounts.containsKey(record.AccountId))
            accounts.get(record.AccountId).Count_Contact__c++;
    try {
        update accounts.values();
    } catch(Exception e) {
        for(Contact record: Trigger.new)
            record.addError('Failed to update account');
    }
}

Sample Code: Modified

    try {
        if(Test.isRunningTest() && globalFlags.crashTest) {  // Purposely crash test.
            accounts.values()[0].Id = null;
        }
        update accounts.values();
    } catch(Exception e) {
        for(Contact record: Trigger.new)
            record.addError('Failed to update account');
    }

globalFlags would be a class that holds static values for various things. This flag, called crashTest, would be set to true before attempting to update the records. When the trigger sees that it's supposed to crash, it does. You can test your code both ways, once with the flag set, the other with the flag cleared. This will help you cover 100% code.

However, this sort of technique isn't recommended for casual optimization of code coverage, because it introduces test behavior in your production code. Such code can later become the source of mystery failures, such as when a test method starts failing because the code though it should crash, or a bug elsewhere somehow causes the trigger to think it's testing and crashes in production. It also increases testing time by requiring developers to actually navigate to the page/record/etc and manually verify that it doesn't crash after code changes.

Of course, one also has to realize that sometimes you can't avoid testing in production code, although the exceptions to the rule of not mixing test code into production are becoming fewer now as testing improves (such as mock callout responses).

One other strategy that does help, though, is to create a class specifically for handling database errors that can be independently tested.

First, you'd change the logic to not use exception handling:

globalUtils.renderErrors(Database.update(olis_updated, false), Trigger.new);

Next, you'd construct your class and method:

public class globalUtils {
    public static void renderErrors(Database.SaveResult[] results, OpportunityLineItem[] inputs) {
        for(Integer idx = 0; idx < results.size(); idx++)
            if(!results[idx].isSuccess())
               inputs[idx].addError('Failed to update on this record');
    }
}

To test globalUtils, you can forge a test method that will automatically cover the error, such as:

OpportunityLineItem[] src = new OpportunityLineItem[0], dst = new OpportunityLineItem[0];
OpportunityLineItem tst = new OpportunityLineItem();
src.add(tst);
dst.add(tst);
globalUtils.renderErrors(Database.update(src,false),dst);

[SalesForce] Problem with try catch block inside trigger

As you are in a before trigger and your acclist contains the elements from trigger.new, any changes you make to those records will be applied when the trigger completes.

I'd imagine the DML exception you are getting is that you can't execute an update on records that are in trigger.new. You are catching this exception and handling it, so the trigger then continues and the changes you make are persisted to the database.

In order to unwind the changes, you'd need to clone the trigger.new records and in your catch block change them back to their state when the trigger started.

Best Answer

Related Solutions

[SalesForce] Test Code coverage catch block

Sample Code: Original

Sample Code: Modified

[SalesForce] Problem with try catch block inside trigger

Related Topic