Category: Development

How to unit test Flows in Salesforce with Apex

September 3rd, 2023
Reading Time: 3 minutes
By performing unit tests you can ensure that your rules are error-free, functioning properly, and enforcing the intended business logic. This ultimately leads to a more robust and reliable code.

In Salesforce, a Flow is a powerful tool that allows you to automate business processes by visually designing and executing a series of actions, known as a Flow. It serves as a declarative way to build and automate complex business logic without writing custom code.

A Flow consists of multiple elements, such as screens, variables, decisions, loops, assignments, and more, which are used to define the behavior and functionality of the process. You can think of it as a sequence of steps that guide users or make automated decisions based on specified criteria.

Overall, Flows provide a flexible and intuitive way to automate business processes in Salesforce without writing code. They allow you to streamline workflows, guide users, make decisions, update records, and perform various other actions to achieve your desired automation goals.

Unit testing Flows in Salesforce with Apex is crucial for several reasons:
1. Error prevention: Unit tests help identify errors or issues in Flows before they are deployed to a production environment. By catching and fixing errors early on, you can prevent potential data integrity issues and ensure the accuracy of your Flows.
2. Increased confidence: Unit tests give you confidence that your Flows are working as intended. By systematically testing different scenarios, you can validate that the Flows are correctly processing data and executing the desired functionality.
3. Regression testing: Unit tests act as a safety net when making changes to existing Flows. Whenever a change is made, these tests can be re-run to ensure that the modifications haven’t inadvertently broken any existing functionality.
4. Documentation: Unit tests serve as living documentation that demonstrates and validates how your Flows should behave. They allow developers and administrators to understand the expected behavior of the Flows and ensure consistent behavior across different deployments or instances.
5. Facilitates collaboration: Unit tests promote collaboration between developers and administrators by providing a clear understanding of the purpose and behavior of the Flows. This enables better communication and collaboration when discussing requirements or troubleshooting issues related to the Flows.
To unit test Flows in Salesforce using Apex, you can follow these steps:
1. Identify the Flow you want to test: Determine the specific Flow you need to create unit tests for.
2. Prepare test data: Create or gather test data that represents different scenarios within the Flow. This includes the input variables that the Flow relies on.
3. Create an Apex test class: In Salesforce, create an Apex test class to test your Flow. The test class should be annotated with @isTest.
4. Trigger the Flow by, for example, saving a record with some particular data. Make sure you wrap this section of the test with Test.startTest(); and Test.stopTest();
5. Assert the outcome: Access the Flow’s output variables and assert that their values match the expected results. You can use Apex assertions such as System.assertEquals to compare expected and actual values.
6. Run the test class: Execute the test class to run the unit tests for your Flow. You can run the tests using the Developer Console or Salesforce CLI.
It’s not recommended you test different scenarios in the same test. As a good practice, create one method for every scenario you want to test.

Unfortunately, until now you don’t have a way to know how well the Flow is covered so you won’t be able to know if you tested every scenario in the Flow.

By following these steps, you can effectively unit test Flows in Salesforce using Apex. This helps ensure that your Flows function as expected and handle different scenarios correctly.
Mocking AWS SSM with Jest and TypeScript

March 29th, 2023
Reading Time: 3 minutes
Mocking in software development offers several advantages, but one of the most important ones is the ability to isolate and control dependencies. Here are a few key advantages of mocking:
1. Test Independence: By using mocks, you can test a specific unit of code in isolation, without relying on the behavior of external dependencies. This ensures that your tests are independent and not affected by changes in other parts of the system.
2. Faster and Repeatable Testing: Mocking allows you to simulate the behavior of external components or services, making your tests faster and more repeatable. You can define specific responses or scenarios, which eliminates the need for time-consuming interactions with real components.
3. Reduced Complexity: Mocking simplifies the testing process by removing the need to set up complex and often resource-intensive external dependencies. This leads to cleaner and more focused tests that are easier to understand and maintain.
4. Improved Fault Isolation: Mocking helps identify and isolate faults within your codebase. By substituting external dependencies with mocks, you can pinpoint the source of errors or unexpected behavior more easily, making debugging and troubleshooting faster and more efficient.
5. Parallel Test Execution: With mocks, you can run tests in parallel without worrying about conflicts or interdependencies between different components. This speeds up the test execution time and improves overall testing efficiency.
Overall, mocking enables developers to write robust, reliable, and efficient tests by allowing them to control the behavior of external dependencies. It promotes testability, enhances the development process, and helps deliver high-quality software.

This time let’s see an example about mocking AWS SSM

Let’s say you have this code that uses SSM:
```
import { SSM } from 'aws-sdk';

const getSecureParameter = async (paramName: string): Promise<string | undefined> => {
    if (paramName.startsWith('/wrong')) throw new Error('wrong parameter');
    const ssm = new SSM();
    const secret = await ssm
        .getParameter({
            Name: paramName,
            WithDecryption: true,
        })
        .promise();
    return secret.Parameter ? secret.Parameter.Value : undefined;
};

export const getParam1 = () => getSecureParameter('/ssm/param/name/example');
export const getParam2 = () => getSecureParameter('/wrong/param');
export const getParam3 = () => getSecureParameter('/not/found/param');
```
To mock AWS SSM with Jest and TypeScript, you can use the AWS SDK’s mock implementation. Here’s how you can set it up:
```
import AWS from 'aws-sdk';
import { getParam1, getParam2, getParam3 } from '../mock';

jest.mock('aws-sdk');

const mockAws = AWS as jest.Mocked<any>;

const ssmMock = {
    getParameter: (options: AWS.SSM.Types.GetParameterRequest) => {
        return {
            promise: () => {
                switch (options.Name) {
                    case '/not/found/param': {
                        return Promise.reject(new Error('some error'));
                        break;
                    }
                    default: {
                        return Promise.resolve({
                            Parameter: {
                                Value: `mocked secret for ${options.Name}`,
                            },
                        });
                    }
                }
            },
        };
    },
};

describe('AWS SSM mock example tests', () => {
    beforeAll(() => {
        mockAws.SSM.mockImplementation(jest.fn().mockImplementation(() => ssmMock));
    });

    beforeEach(() => {
        //
    });

    it('should success when...', async () => {
        // example
        const result = await getParam1();
        expect(result).toBe('mocked secret for /ssm/param/name/example');
    });

    it('should fail due to some reason...', async () => {
        // example:
        await expect(getParam2()).rejects.toThrow(new Error('wrong parameter'));
    });

    it('should fail due to another reason...', async () => {
        // example:
        await expect(getParam3()).rejects.toThrow(new Error('some error'));
    });
});
```
Mocking in software development offers several advantages, with the ability to isolate and control dependencies being one of the most important. By using mocks, developers can test specific units of code in isolation, leading to test independence and faster, repeatable testing. Mocking also reduces complexity by eliminating the need for complex external dependencies, allowing for cleaner and more focused tests. Additionally, fault isolation is improved as mocking helps identify and isolate faults within the codebase. With mocks, tests can also be executed in parallel, improving overall testing efficiency.

In the example of mocking AWS SSM with Jest and TypeScript, the AWS SDK’s mock implementation is used. By setting up the mock implementation, developers can simulate the behavior of AWS SSM and test their code without relying on the actual AWS services. This allows for more controlled and reliable testing.

Overall, mocking enables developers to write robust, reliable, and efficient tests by allowing them to control the behavior of external dependencies. It promotes testability, enhances the development process, and helps deliver high-quality software. With the ability to isolate and control dependencies, developers can confidently test their code and ensure its functionality without being dependent on external factors.

November 10, 2023How to publish Salesforce platform events from Salesforce API from Node.js
November 8, 2023Advantages of using map over for loops in JavaScript
November 8, 2023Different ways to use for loops in Node.js
October 13, 2023Switch between different Node versions
October 7, 2023How to connect to a Redshift Database in Node.js
February 24, 2023Node.js with Express and MySQL scaffold
February 23, 2023Caching large data with Redis
February 14, 2023How to use Handlebars in an AWS Lambda function
How to Mock Axios with Jest

March 28th, 2023
Reading Time: < 1 minute
Axios is a popular JavaScript library used for making HTTP requests in web applications. Jest, on the other hand, is a JavaScript testing framework that comes with a built-in mocking feature that makes it easy to mock Axios in your tests. In this blog post, we’ll explore how to mock Axios with Jest, step by step.

To mock Axios with Jest, you can use the Jest mock function to replace the actual Axios library with a mock implementation.

Here is an example of how to mock Axios with Jest:
```
// Import the Axios library
import axios from 'axios';

// Mock the Axios library with Jest
jest.mock('axios');

// Define the mock response data
const mockResponse = {
  data: {
    id: 1,
    name: 'John Doe',
  },
};

// Set up the mock implementation for Axios
axios.get.mockImplementation(() => Promise.resolve(mockResponse));

// Call the Axios method in your test
axios.get('/users/1').then((response) => {
  expect(response.data).toEqual(mockResponse.data);
});
```
In the example above, we first import the Axios library and then mock it with Jest. We then define a mock response data object and set up the mock implementation for the Axios get method to return a Promise that resolves with the mock response data.

Finally, we call the Axios get method in our test and use Jest’s expect function to assert that the response data matches the mock response data.

Note that you may need to modify this example to suit your specific use case, depending on the methods you are calling and the data you are expecting in response.

November 10, 2023How to publish Salesforce platform events from Salesforce API from Node.js
November 8, 2023Advantages of using map over for loops in JavaScript
November 8, 2023Different ways to use for loops in Node.js
October 13, 2023Switch between different Node versions
October 7, 2023How to connect to a Redshift Database in Node.js
February 24, 2023Node.js with Express and MySQL scaffold
February 23, 2023Caching large data with Redis
February 14, 2023How to use Handlebars in an AWS Lambda function
How to detect if a string is a number with regex (with JavaScript example)

March 27th, 2023
Reading Time: < 1 minute
To detect if a string is a number with regex, you can use the following regular expression:
```
^-?\d+(\.\d+)?$
```
Explanation:
- ^ matches the start of the string
- -? matches an optional minus sign (-)
- \d+ matches one or more digits
- (\.\d+)? matches an optional decimal point followed by one or more digits
- $ matches the end of the string
This regular expression will match any string that represents a number, including integers and decimal numbers, with or without a leading minus sign.

Here’s an example of how to use this regular expression to check if a string is a number in JavaScript:
```
function isNumber(str) {
  return /^-?\d+\.?\d*$/.test(str);
}

console.log(isNumber('42')); // true
console.log(isNumber('-3.14')); // true
console.log(isNumber('0')); // true
console.log(isNumber('4.2.1')); // false
console.log(isNumber('hello')); // false
```
The test method returns true if the regular expression matches the given string, and false otherwise.

Category: Development

How to unit test Flows in Salesforce with Apex

Mocking AWS SSM with Jest and TypeScript

How to Mock Axios with Jest

How to detect if a string is a number with regex (with JavaScript example)