Example: Write a test class for our deduping trigger!

Preface – This post is part of the Write Your First Intermediate Trigger series.

Let’s write a test class for our deduping trigger, using Apex testing best practices!

Here’s a look at the test class – we’ll do a line-by-line breakdown immediately afterwards:

@isTest 
public class TestFindDupes {
    static testMethod void testDupes() {

       // Let's create our records from scratch!
       Contact c   = new Contact();
       c.FirstName = 'Stephen';
       c.LastName  = 'Curry';
       c.Email     = 'stephcurry@gsw.com';
       insert c;
       
       // Now let's create a dupe lead
       Lead dupeLead      = new Lead();
       dupeLead.FirstName = 'Steph';
       dupeLead.LastName  = 'Curry';
       dupeLead.Company   = 'Golden State Warriors';
       dupeLead.Email     = 'stephcurry@gsw.com';
       
       // This is a special way of doing "risky" things
       try {
           insert dupeLead;
       } catch (Exception e) { 
           System.debug('An error happened, as predicted!');
       }
       
       // Now we try to find our dupe lead, by email
       List<Lead> dupes = [SELECT Id FROM Lead 
                      WHERE Email = 'stephcurry@gsw.com'];
       System.assertEquals(0, dupes.size());
      
       // Now we "break" our trigger by inserting a non-dupe
       Lead legitLead      = new Lead();
       legitLead.FirstName = 'David';
       legitLead.LastName  = 'Lee';
       legitLead.Company   = 'Golden State Warriors';
       legitLead.Email     = 'dlee@gsw.com';
       insert legitLead;
       // Now we try to find our legit lead, by email
       List<Lead> legits = [SELECT Id FROM Lead 
                               WHERE Email = 'dlee@gsw.com'];
       System.assertEquals(1, legits.size());
    }
}

Don’t be intimidated – there’s a decent amount of code but none of it is complicated!
Let’s do a line by line analysis:

@isTest 
public class TestFindDupes {
    static testMethod void testDupes() {
        ...
    }
}

The above is the usual “fluff” that you don’t need to worry about.

       // Let's create our records from scratch!
       Contact c   = new Contact();
       c.FirstName = 'Stephen';
       c.LastName  = 'Curry';
       c.Email     = 'stephcurry@gsw.com';
       insert c;

We’re creating a new contact from scratch (Testing Best Practice #1!) that will serve as the “original” record to dedupe against. Remember that we use the email address to know if it’s a dupe or not! There can never be another Steph Curry!

       // Now let's create a dupe lead
       Lead dupeLead      = new Lead();
       dupeLead.FirstName = 'Steph';
       dupeLead.LastName  = 'Curry';
       dupeLead.Company   = 'Golden State Warriors';
       dupeLead.Email     = 'stephcurry@gsw.com';

We’re creating a dupe lead (by email address) – remember that nothing happens until we insert it!

       // This is a special way of doing "risky" things
       try {
           insert dupeLead;
       } catch (Exception e) { 
           System.debug('An error happened, as predicted!');
       }

You don’t have to understand this part above but I’ll explain what’s happening anyway.

This technique is known as a try/catch statement. It lets you “try” to do something that may break your code (like divide by zero, or in our case, insert a dupe). If an error is “caught”, it doesn’t break your code and lets you move on.

Without try/catch, our code would break here! We’ll cover this and System.debug in a future chapter!

       // Now we try to find our dupe lead, by email
       List<Lead> dupes = [SELECT Id FROM Lead 
                      WHERE Email = 'stephcurry@gsw.com'];
       System.assertEquals(0, dupes.size());

Now that we attempted to create the dupe lead, we try to find it using SOQL. Test classes are run in a “clean” version of your org – all records are wiped! So the only records that exist are the ones we created in this test.

We use System.assertEquals() to check that no leads with the duplicate email are found. We check this by making sure there are exactly 0 leads that are returned by the SOQL query. If a lead is found, it means that our trigger isn’t working as expected, and System.assertEquals() will error out the test. Using System.assertEquals() is Testing Best Practice #2!

       // Now we "break" our trigger by inserting a non-dupe
       Lead legitLead      = new Lead();
       legitLead.FirstName = 'David';
       legitLead.LastName  = 'Lee';
       legitLead.Company   = 'Golden State Warriors';
       legitLead.Email     = 'dlee@gsw.com';
       insert legitLead;
       // Now we try to find our legit lead, by email
       List<Lead> legits = [SELECT Id FROM Lead 
                               WHERE Email = 'dlee@gsw.com'];
       System.assertEquals(1, legits.size());

We’re creating a lead that isn’t a dupe now and checking that our trigger doesn’t incorrectly catch it! By testing scenarios that our trigger shouldn’t work on, we’re fulling Testing Best Practice #3!

Login to Sfdc99 to see this test class in action!

Very proud of you for making it through the first four chapters of Sfdc99! We’re ready to start moving on to some more advanced techniques!

Very soon now you’ll be a full-fledged Salesforce developer!

Next post: Introduction to Governor Limits!