Tag: jest

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
Mock Axios with Jest

May 11th, 2021
Reading Time: 2 minutes
Mocking in unit tests serves several purposes:
1. Control Dependencies: Unit tests should focus on testing specific units of code in isolation. By mocking dependencies, such as external API calls, databases, or services, you can control their behavior and ensure that the unit being tested is the sole focus. This helps in eliminating external factors that could interfere with the test results and isolates the unit under test.
2. Increase Test Speed: Some dependencies may have slow response times or require specific setups before they can be tested. By mocking these dependencies, you can bypass the need for actual communication with external systems, leading to faster test execution. Mocking allows you to test more scenarios in a shorter amount of time, which is especially beneficial when running a large suite of tests.
3. Reproduce Specific Scenarios: Mocking provides a way to simulate different scenarios or edge cases that may be difficult or time-consuming to reproduce in real-world situations. By creating mock responses or throwing specific errors, you can assess how the unit being tested handles different scenarios and ensure its robustness.
4. Reduce Test Flakiness: Dependencies like external APIs or databases can introduce non-deterministic behaviors, such as network issues or data inconsistencies. By mocking these dependencies, you eliminate their unpredictability and make your tests more deterministic and reliable. This reduces the chances of false positives or false negatives in your test results.
5. Isolate Faults: If a test fails, mocking can help you narrow down the cause to the specific unit being tested or its direct dependencies. By mocking, you can identify whether the issue lies within the unit itself or in its interactions with external components. This simplifies the debugging process and allows for more targeted fixes.
Overall, mocking during unit tests provides greater control, speed, reproducibility, reliability, and fault isolation, enabling you to thoroughly test individual units of code in an efficient and focused manner.

Example of mocking with a successful response
```
      
import axios from "axios";

jest.mock("axios");
const mockedAxios = axios as jest.Mocked<typeof axios="">;

 const mockGet = jest.fn();
    mockGet.mockImplementation(() => {
      const myResponse = {
        status: 200,
        data: {
          data: [{ id: 1 }, { id: 2 }],
        },
      };

      return Promise.resolve(myResponse);
    });
    mockedAxios.get.mockImplementation(mockGet);
      </typeof>
```
Example of mocking with an error response
```
      
import axios from "axios";

jest.mock("axios");
const mockedAxios = axios as jest.Mocked<typeof axios="">;

const mockGet = jest.fn();
    mockGet.mockImplementation(() => {
      const error = {
        response: {
          status: 404,
        },
      };
      return Promise.reject(error);
    });
    mockedAxios.get.mockImplementation(mockGet);
      </typeof>
```

Tag: jest

Mocking AWS SSM with Jest and TypeScript

How to Mock Axios with Jest

Mock Axios with Jest

Example of mocking with a successful response

Example of mocking with an error response