Increasing the performance of Apex tests

Increasing the performance of Apex tests in Salesforce is essential for maintaining a fast and efficient CI/CD pipeline, ensuring that developers get quick feedback on their code. In Salesforce, the speed of Apex tests can be significantly affected by how you interact with the database and how you structure your tests. Here’s a detailed tutorial on optimizing your Apex tests for performance:

1. Understand Test Types: Unit Tests vs. Integration Tests

Unit Tests:

  • Focus on a single piece of functionality.
  • Mock external dependencies.
  • Require minimal data setup.
  • Run quickly since they are isolated.

Integration Tests:

  • Test the interaction between multiple components.
  • Often require data setup in a Salesforce org, which may involve multiple DML operations and SOQL queries.
  • Tend to run slower due to the larger scope.

2. Use Mocking Frameworks

Why Use Mocks?

  • To avoid making unnecessary calls to the database or external services.
  • To focus on the logic you are testing rather than the setup.
  • To prevent test failures due to data validation rules, triggers, or process flows that are not relevant to the test context.

How to Use Mocks:

  • Implement Salesforce’s HttpCalloutMock interface for mocking HTTP callouts.
  • Use the StubProvider interface to mock Apex classes and interfaces.


public class MyHttpCalloutMock implements HttpCalloutMock {
    public HTTPResponse respond(HTTPRequest req) {
        // Create a fake response
        HttpResponse res = new HttpResponse();
        res.setBody('Mocked response');
        return res;


  • Use Test.setMock to inject your mock response into your tests.

3. Optimize Test Data Creation

  • Use @testSetup to create test records once and then use them across multiple test methods, reducing the amount of DML operations.
  • Utilize the Test.loadData() method to bulk insert test data from static resource files, avoiding the need for multiple DML statements.


static void setup() {
    // Create and insert test data


4. Reduce SOQL Queries

  • Ensure that each test is making only the necessary SOQL queries.
  • Use the Limits class to monitor the SOQL queries in each test.
  • Optimize your code to query only the fields that are necessary.
  • Apply selective queries and avoid SELECT * patterns.

5. Analyze Test Coverage and Remove Redundant Tests

  • Use the Salesforce Developer Console or the sfdx force:apex:test:run command with the -c flag to check test coverage.
  • Look for overlapping test scenarios that may be testing the same logic.
  • Remove or consolidate tests that do not contribute to unique coverage.

6. Segregate Tests Using Unlocked Packages


  • Tests can be organized based on the functionality they cover.
  • Each unlocked package can be deployed and tested independently.
  • Reduces the number of tests to run for a specific set of changes.

Implementing Unlocked Packages:

  • Break down your org’s metadata into logical units.
  • Migrate tests related to specific features into their respective unlocked packages.
  • Use Salesforce CLI to create and manage unlocked packages.
  • Deploy and test unlocked packages independently to reduce test execution time.

7. Monitor and Optimize Test Execution

  • Use the Test.startTest() and Test.stopTest() methods to reset governor limits for the test’s execution context.
  • Run tests in parallel where possible, but be aware that this can lead to row locking issues.
  • Monitor the execution time of your test suite regularly to identify slow-running tests.

8. Best Practices for Efficient Apex Tests

  • Write small, focused test methods.
  • Avoid using seeAllData=true unless it’s absolutely necessary, as it slows down tests and can lead to data-dependent tests.
  • Mock data and service layer calls whenever possible.
  • Refactor tests when modifying existing code to ensure they remain fast and reliable.


By following these strategies, you can significantly increase the performance of your Apex tests in Salesforce. Utilizing mocking frameworks to avoid database calls, focusing on unit tests for faster execution, optimizing test data creation, reducing SOQL queries, eliminating redundant tests, and effectively using unlocked packages are all crucial steps. Continuous monitoring and optimization of your test suite are key to maintaining performance gains over time.

Leave a Comment