Salesforce Testing

Anushree Chatterjee

Salesforce is a cloud-based customer relationship management (CRM) platform designed to help businesses manage customer interactions and relationships. It provides a suite of tools for managing sales, marketing, customer service, and analytics, all accessible through a web browser or mobile app.

In this article, we will review various types of Salesforce testing (unit, integration, end-to-end), useful tools, and common testing scenarios.

Automated Salesforce Testing

Salesforce testing can be done manually or through automated testing tools. Automated testing tools can speed up the testing process, improve accuracy, and reduce the risk of human error. When it comes to backend development and testing, Apex is used, which is a strongly typed, object-oriented language that is syntactically similar to Java. For the front end, Salesforce has Lightning frameworks.

The testing pyramid approach is a good way to maximize test coverage and quality. This means that the following types of testing need to be done.

• End-to-end testing
• Integration testing
• Unit testing

End-to-End Testing

Let us find out how to perform end-to-end testing and automation of Salesforce.

Why Traditional Test Automation Tools Struggle With Salesforce Testing

If you’re looking to test your Salesforce setup from a user’s perspective, then you need tools that will help you run UI, functional, and end-to-end test cases. You will need more than traditional test automation tools like Selenium to automate Salesforce use cases for the following reasons:

• Dynamic Nature of Salesforce: Salesforce is constantly changing because it’s a cloud-based application that gets updated regularly. These updates might introduce new features or change the user interface. Traditional tools like Selenium are designed to work with static web pages, and hence, they can struggle with the dynamic content and constantly evolving nature of Salesforce.
• Complex User Interface: Salesforce has a highly complex UI with many nested components, dynamic elements, and custom-built features. These can make it difficult for traditional tools to interact with elements reliably. For example, Salesforce pages might load elements asynchronously (after the page is already loaded), making it tough for such tools to accurately find and interact with the right elements at the right time.
• Heavy Reliance on Locators: Selenium depends on “locators” (like element IDs, class names, etc.) to identify parts of the page to interact with. In Salesforce, many of these locators can change often, especially since Salesforce customizations and third-party apps might alter page structures. If locators change, test scripts break, which requires constant maintenance.
• Salesforce-Specific Challenges: Salesforce has many unique features (like custom objects, Visualforce pages, and Lightning components) that don’t always play well with traditional test automation tools. These features require specific handling, which might not be out-of-the-box with traditional tools.
• Integration with Other Systems: Salesforce is often integrated with many other systems (ERP, email, etc.), which means test scenarios are rarely isolated. Traditional tools might fail when there are issues with these integrations, or it can be difficult to set up tests that cover multiple systems.

Why Salesforce’s Built-in Tools Don’t Work for End-to-End Testing

The thing with relying solely on the Apex testing framework, Salesforce Sandbox, and other built-in testing capabilities is that they are very niche.

Let’s talk about the Apex Test Classes first.

If you want to write unit tests, then the Apex framework is good. But if you’re testing the integration between backend logic and the front-end UI, Apex alone won’t give you a full picture of how things work together. This is because Apex cannot interact directly with Lightning Web Components (LWC) or Visualforce pages.

Similarly, Flow Builder tests are designed to test individual flows, not complex end-to-end scenarios that involve multiple flows or other Salesforce components. Flows perform data manipulation (DML operations) automatically, which means they may be harder to control or mock during testing. This makes it difficult to fully simulate complex end-to-end data workflows, particularly when the flow interacts with multiple objects or involves updating many records at once. Unlike Apex, which provides detailed test logs and error messages, Flow Builder has limited visibility into the results of a flow test. Debugging can be harder, and understanding why a flow failed may require detailed logging or manual step-by-step inspection.

Why Do These Limitations Matter for E2E Testing?

• Inability to Test UI Interactions: None of these tools help test the UI, that is, interact with the application like a regular user would. You can’t simulate the experience of a user interacting with the front end of Salesforce, nor can you validate user interface behavior effectively through flow tests alone.
• Unable to Test All Integrations: These tests are restricted to the Salesforce ecosystem, meaning you can’t easily test integrations with external systems (unless those systems are tightly coupled with Salesforce). This can limit the ability to test entire business processes that involve external systems, third-party APIs, or other tools.
• Incomplete Coverage: Relying solely on Apex tests and Flow Builder tests can leave significant gaps in test coverage, particularly for scenarios that involve user interactions and external integrations.
• Increased Risk of Defects: Without comprehensive end-to-end testing, there’s a higher risk of defects slipping through to production, which can lead to negative user experiences and business disruptions.

You need something quicker and easier to use for everyone on your team. While you may be managing with the above-mentioned options, you can simplify testing by leveraging AI.

AI-powered End-to-End Testing

testRigor is an intelligent cloud-based tool that uses generative to make software testing super easy, not just for testers but for everyone on the team. This tool is a one-stop solution for end-to-end, functional, UI, regression, and even API testing of your Salesforce application. testRigor does not need access to the Salesforce code as it tests the application like a human, all thanks to its AI engine. Let’s see how it does this.

• Cloud-hosted: It is a cloud-hosted tool, so you do not need to invest money and resources to set up an environment and maintain the software. Just subscribe and start creating automation scripts right away.
• Eliminates Code Dependency: The issue with tools like Selenium is that they require you to write code to do the most basic of operations like click buttons. This limits who can be a part of the QA process. Most often, those who know what users use are manual testers and non-technical folks like product owners, system administrators, and sales representatives. With a tool like testRigor, they can easily review and even write English test cases. In fact, there are many ways to create tests in testRigor that do not require one to write them. Take a look at the different ways to create test cases: All-Inclusive Guide to Test Case Creation in testRigor.
• Salesforce-specific Commands: It gets even better – testRigor has custom commands for the Salesforce testing that let you directly create objects, search and validate them. Here’s a full list of Salesforce commands – Built-in testRigor Reusable Rules for Salesforce (Examples below).

You can do more like:

• Build tests that run in the UI and also validate changes in data using Salesforce REST API.
• Validate high-level use cases that cross system boundaries (E.g., “Enter Lead in website with detail X then check that it is assigned correctly to Queue Z in Salesforce”) as opposed to low-level validations (E.g., “Create Lead with detail Y then check that the Lead Rating should be ‘High’). Thus, you can retain the business language without compromising the ability of the test case.
• AI capabilities: testRigor’s AI engine gives you an edge as it offers multiple capabilities like:
  • Self-healing tests that can handle elements moving around, element labels changing, and more.
  • Visual testing capabilities that can come in handy for regression testing.
  • Context-based testing, where your prompts to the test engine will guide it in finding elements to interact with or verifying them without requiring you to provide technical implementation details like XPaths or CSS Selectors.
• Simple Interface: The UI is straightforward and does not involve too many bells and whistles. Create a test suite, run it, and review reports. Check it out over here.
• One Tool Solves Everything: testRigor performs not just web automation; it can help you run the following test types seamlessly:
  • Web and Mobile browser testing
  • Mobile app testing
  • Desktop app testing
  • API testing
  • Visual testing
  • Accessibility testing
  • Mainframe testing
  • Graph testing
  • Image testing
  • Chatbot and LLM testing

You don’t have to install different tools for different types of testing; testRigor takes care of all your testing needs singlehandedly.

• Reduced Test Maintenance: Test maintenance has been a problem since the dawn of times (for test automation). Luckily, with testRigor, the story changes. This tool uses AI to ensure that flakey test runs are avoided. This is thanks to testRigor’s element location strategy (as described below).
• Stable Element Locators: Unlike traditional tools that rely on specific element identifiers, testRigor uses a unique approach for element locators. You simply describe elements by the text you see on the screen, leveraging the power of AI to find them. This means your tests adapt to changes in the application’s UI, eliminating the need to update fragile selectors constantly. This helps the team focus more on creating new use cases than fixing the flaky XPaths/CSS locators.
• Integrations: testRigor offers built-in integrations with most of the popular CI/CD tools like Jenkins and CircleCI, test management systems like Zephyr and TestRail, defect tracking solutions like Jira and Pivotal Tracker, infrastructure providers like AWS and Azure, and communication tools like Slack and Microsoft Teams. You can also import/copy-paste your manual test cases from test management systems, such as TestRail, Zephyr, PractiTest, etc., into testRigor and execute them directly as automated tests after making small tweaks.

Whether you want to follow BDD, TDD, shift-left testing, or any other methodology, testRigor lets you do it easily. Write tests across platforms and browsers with this one-tool-army solution. Since it is so easy to create test cases in testRigor, in the event that any Salesforce module is phased out (like Workflow Rules and Process Builders) and replacements are introduced, regression testing will become imperative. Due to the adaptability and scalability of testRigor, you’ll be able to easily test this transition and not incur heavy test maintenance costs.

How to use testRigor to test Salesforce?

Don’t change this section in the original article – https://testrigor.com/blog/salesforce-testing/#how_to_use_testrigor_for_salesforce_testing

testRigor’s Special Reusable Rules for Salesforce Testing

We mentioned testRigor’s special commands or reusable rules that let you automate Salesforce use cases in plain English. In fact, this is even simpler and more concise than the steps mentioned above.

login
create new Leads
pick Mr from Salutation in Salesforce
search and pick "Peterson" from "Grandfarther" in Salesforce
generate unique name, then enter into "Last Name" and save as "generatedName"
generate unique name, then enter into "Company" and save as "generatedCompany"
click "Save" to the right of "Cancel"
navigate to leads using app launcher

search for stored value "generatedName" of type "Leads" and open

Isn’t that easy? It is as good as writing test steps for manual automation.

Learn more here about the powerful features of testRigor.

Integration Testing

The goal of integration testing is to verify that the different components of the system work together as expected and that data is accurately passed between the different components.

Integration testing can be used to test the integration between different Salesforce components, such as custom code, workflows, triggers, and external systems. You can use the same tools as above for backend and frontend test writing and execution.

Here are some examples of scenarios where integration testing is typically needed

• Integrating with third-party APIs: If you are building an application that integrates with third-party APIs, such as payment gateways, email providers, or social media platforms, you need to perform integration testing to ensure that data is being exchanged correctly and that the application is behaving as expected.
• Custom integrations: If you are building custom integrations between Salesforce and other systems, such as an ERP or a marketing automation platform, you need to perform integration testing to ensure that data is being exchanged correctly and that the integration is working as expected.
• Upgrading Salesforce: If you are upgrading your Salesforce instance by adding new features, you need integration testing to ensure that the changes don’t impact any of the existing integrations.
• Changes to integrations: If you are making changes to any of the existing integrations, such as adding new fields or updating workflows, you need to perform integration testing to ensure that the changes don’t cause any issues.
• Data migration: If you are migrating data from another system to Salesforce, you need to perform integration testing to ensure that the data is being migrated correctly and that the new data is compatible with the existing data in Salesforce.

Unit Testing

Unit testing is meant to test whether each unit of code, such as classes, methods, or components, is working as expected. The focus is strictly on the code’s output. These kinds of tests are run in isolation and, hence, need to be lightweight.

The Salesforce ecosystem provides some tools to perform unit testing, such as:

Apex testing framework

What is it?

Salesforce uses Apex as a programming language to build and customize functionality. It is designed specifically for the Salesforce platform and can be used to create custom business logic, automate processes, integrate with external systems, and create custom user interfaces.

How to write tests in Apex?

In Salesforce, the @isTest annotation is used to mark a class or method as a test class or test method. You can execute your tests using the following:

• Apex Test Execution page: This feature in the Salesforce UI allows developers to run Apex tests asynchronously and view the test results. Developers can use filters to view test results by class, method, outcome, and more.
• Developer Console: The Developer Console is a tool within Salesforce that provides a range of features for developers, including the ability to create and run tests, execute anonymous Apex code, and debug code.
• Using the API: You can use the runTests() call to run tests synchronously. Based on what you specify in the RunTestsRequest object, this single call allows you to execute tests in a specific namespace, tests in a specific subset of classes in a specific namespace, or tests in all classes. You can also choose to run your tests synchronously or asynchronously.
• Using ApexTestQueueItem: You can use the ApexTestQueueItem to run your tests asynchronously. The tests get added to a job queue and the results are made available once the execution is done. Since this process makes use of the Apex scheduler, you can schedule your tests to run at specific times.

Lightning Testing Service (LTS)

What is it?

Lightning Testing Service (LTS) is a Salesforce tool that acts as a bridge between JavaScript testing tools and the Salesforce platform. It provides a way to test the Lightning components and applications developed using the Salesforce Lightning web components framework.

LTS runs the tests in a headless browser environment and provides support for testing frameworks such as Jest, Mocha, and Jasmine. It enables developers to write unit tests, integration tests, and end-to-end tests for their Lightning components and applications.

Lightening Web Components (LWC)

What is it?

While LTS is still used, LWC is the newer and more popular framework for Salesforce web components. This framework, too, recommends using the Jest testing framework, a popular and powerful JavaScript testing library. You can use this framework to write unit tests, integration tests, and even UI tests.

Salesforce Testing Scenarios

Here are some examples of Salesforce testing scenarios that you might end up verifying

• Lead Conversion Testing
  Scenario: Verify the conversion of a lead into an account, contact, and opportunity. Check that lead-specific data (like campaign history) is transferred correctly.
• Opportunity Management Testing
  Scenario: Test the creation (associate it with an account), updating, and closing of opportunities.
• Custom Object Testing
  Scenario: Ensure that a custom object with various field types (text, picklist, date, etc.) is functioning as expected.
• Workflow Testing
  Scenario: Validate that workflow rules trigger the correct actions (e.g., sending an email alert or updating a field).
• Salesforce Mobile App Testing
  Scenario: Ensure that the Salesforce Mobile app works correctly.
• Role-Based Security Testing
  Scenario: Ensure that role-based access (e.g., Sales Rep, Sales Manager) controls are correctly implemented.
• Data Migration Testing
  Scenario: Test the migration of data from an old CRM system to Salesforce. Migrate a sample set of data, including leads, contacts, accounts, and opportunities, from the old system to Salesforce.
• Integration Testing
  Scenario: Validate the integration between Salesforce and an external system (e.g., an ERP or marketing automation tool).
• Sales Cloud Implementation Testing
  Scenario: Test a full Sales Cloud implementation, i.e., create and manage leads, convert them to opportunities, and move them through the sales pipeline.

Conclusion

The testing process is vital for building dependable and robust applications on the Salesforce platform. This testing can take several forms, including unit testing, integration testing, and end-to-end testing, each playing a distinct role in guaranteeing the quality of the application. Whether you are developing Salesforce apps or using them in your organization, this article might help you to test the app effectively.

Choosing the right testing tool is critical, and you should consider the specific needs of the testing scenario and the capabilities offered by a specific tool. An intelligent candidate like testRigor is going to prove very beneficial for your QA endeavors. With a complete test suite in testRigor, admins and product owners can have peace of mind – they know that Salesforce and related solutions work as designed.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT