Write Test Cases for Class Methods with POST API Call

Write Test Cases for Class Methods with POST API Call

When developing software applications, it's crucial to ensure that the code behaves as expected under different scenarios. One common aspect of modern applications is making API calls to retrieve or manipulate data from external sources. Writing effective test cases for methods that involve API calls helps ensure that these methods work correctly, providing reliable functionality to the application. In this article, we'll explore the process of writing test cases for methods that make API calls, and we'll also discuss the advantages and disadvantages of test case implementation.

The Scenario

Let's consider a scenario where we have a TypeScript class TestClass that makes an API call using the Axios library to fetch data from a remote server. We'll focus on testing the method responsible for fetching data and storing it within the class.

Here's a simplified version of the TestClass class:

TestClass.service.ts:

                    
                          import { Injectable } from '@nestjs/common';
                          import axios from 'axios';
                    
                          @Injectable()
                          export class TestClass {
                            private classData;
                    
                            /**
                            * @param request { "Name":"Shubham", "website":"idkblogs.com" }
                            * @returns { "Name":"Shubham", "website":"idkblogs.com", "id": 101 }
                            */
                            async fetchData(request: any): Promise<any> {
                              const url = 'https://jsonplaceholder.typicode.com/posts';
                              try {
                                const data: any = await axios.post(url, request);
                                const { id } = data;
                                this.classData[id] = data;
                                return data;
                              } catch (err) {
                                console.log(err);
                              }
                            }
                    
                            getData(id: number) {
                              try {
                                return this.classData[id];
                              } catch (err) {
                                console.log(err);
                              }
                            }
                          }
                    
                        

POST API Call

Write Test Cases for Class Methods with POST API Call

Writing Test Cases

To test the fetchData method, we need to create a test suite that covers different scenarios: successful API calls and error handling. In this example, we'll use the Jest testing framework for demonstration purposes.

Test Case for TestClass.service.spec.ts:

                    
                          import axios from 'axios';
                          import { TestClass } from './TestClass.service';
                          
                          jest.mock('axios');
                          const mockedAxios = axios as jest.Mocked<typeof axios>;
                          
                          describe('TestClass', () => {
                            it('fetchData should be defined', () => {
                              const response = {
                                Name: 'Shubham',
                                website: 'idkblogs.com',
                                id: 101,
                              };
                              const instance = new TestClass();
                              const http = jest.spyOn(mockedAxios, 'post');
                              http.mockImplementation((url): any => {
                                if (url.indexOf('https://jsonplaceholder.typicode.com/posts') > 0) {
                                  return {
                                    Name: 'Shubham',
                                    website: 'idkblogs.com',
                                    id: 101,
                                  };
                                }
                              });
                          
                              const fetchData = jest.spyOn(TestClass.prototype as any, 'fetchData');
                              fetchData.mockImplementation(() => {
                                return response;
                              });
                          
                              const req = { Name: 'Shubham', website: 'idkblogs.com' };
                              const results = instance.fetchData(req);
                              expect(results).toBeDefined();
                              expect(results).toHaveProperty('Name');
                              expect(results).toHaveProperty('website');
                              expect(results).toHaveProperty('id');
                              expect(results).toEqual(response);
                            });
                          
                            it('getData should return correct values for ID', () => {
                              const instance = new TestClass();
                              const response = {
                                Name: 'Shubham',
                                website: 'idkblogs.com',
                                id: 101,
                              };
                              const getData = jest.spyOn(TestClass.prototype as any, 'getData');
                              getData.mockImplementation(() => {
                                return response;
                              });
                              const data = instance.getData(101);
                              expect(data).toBeDefined();
                              expect(data).toHaveProperty('Name');
                              expect(data).toHaveProperty('website');
                              expect(data).toHaveProperty('id');
                              expect(data).toEqual(response);
                            });
                          });
                          
                    
                        

Understanding of above test case:

Explanation of the steps:

1. The test case starts with an it block, which describes what the test is going to verify. In this case, it's checking whether the fetchData method is defined and behaves as expected.

2. A mocked response object (response) is defined, simulating the data that the API call is expected to return.

3. An instance of the TestClass is created (instance) to test its methods.

4. The jest.spyOn function is used to create a spy on the post method of the mockedAxios object. This allows you to track when and how the post method is called.

5. The behavior of the post method is mocked using the http.mockImplementation method. If the URL contains a specific string, it returns the response object.

6. Similarly, a spy is created on the fetchData method of the TestClass instance using jest.spyOn.

7. The behavior of the fetchData method is mocked to return the response object.

8. The request data (req) is defined, simulating the data that will be passed to the fetchData method.

9. The fetchData method is called with the request data, and the result is stored in the results variable.

10. A series of assertions are made to verify the behavior of the fetchData method:

• expect(results).toBeDefined();: Checks if the result is defined.
• expect(results).toHaveProperty('Name');: Checks if the result has a 'Name' property.
• expect(results).toHaveProperty('website');: Checks if the result has a 'website' property.
• expect(results).toHaveProperty('id');: Checks if the result has an 'id' property.
• expect(results).toEqual(response);: Checks if the result matches the expected response object.

In summary, this test case verifies whether the fetchData method of the TestClass class behaves correctly when making an API call. It uses spies and mock implementations to control and simulate the behavior of external dependencies, allowing controlled testing of the method's logic and behavior.

Advantages of Writing Test Cases

1. Validation of Functionality: Test cases help ensure that methods behave as intended, preventing unintended side effects or errors in the code.

2. Regression Prevention: Whenever changes are made to the codebase, running tests helps catch regressions – unintended issues that arise due to new changes.

3. Documentation: Well-written test cases serve as documentation for how the methods should be used and what outcomes are expected.

4. Refactoring Confidence: When refactoring code, having comprehensive test coverage gives developers the confidence that they haven't broken existing functionality.

5. Collaboration: Test cases make it easier for multiple developers to collaborate on a project, as they provide a clear understanding of the expected behavior.

Disadvantages of Writing Test Cases

1. Time and Effort: Writing and maintaining test cases require additional time and effort during development, potentially slowing down the process.

2. False Sense of Security: Passing tests don't guarantee bug-free software; there might be scenarios not covered by the existing test cases.

3. Maintenance Overhead: As the codebase evolves, test cases might need to be updated, which can introduce its own maintenance challenges.

4. Complexity: Writing tests, especially for complex scenarios, can be challenging and might lead to additional complexity in the test suite.

5. Overhead on Small Projects: For small projects or prototypes, the overhead of writing extensive test cases might outweigh the benefits.

Write Test Cases for Class Methods with POST API Call

---

Conclusion:

Writing test cases for methods that make API calls is a critical aspect of software development. It ensures that the code functions as intended, even when interacting with external services. By following best practices and considering the advantages and disadvantages, developers can strike a balance between test coverage and development speed, ultimately creating more robust and reliable applications.

Related Keywords:

How to Write Unit Tests for Instance Methods

How do you write a test case for a class?

Write Simple Test Case Using Classes

How to test class methods with jest (on return values)

How to test classes with Jest