/
Guide for Writing JUnit Test Cases for APIs in Java

Guide for Writing JUnit Test Cases for APIs in Java

Owned by Tabassum Ansari (Unlicensed)
Jun 22, 2023
5 min read

Introduction

JUnit is a popular unit testing framework for Java. It provides a simple and effective way to write test cases to verify the functionality of your APIs. This document will guide you through the process of writing JUnit test cases for APIs in Java.

When testing an API on App Engine, it is common to have tests for each of these layers:

  • Endpoint Tests: These tests focus on validating the behavior of the endpoints layer. They typically involve sending mock HTTP requests and asserting the correctness of the responses, including status codes, headers, and payload data. Tools such as JUnit and Mockito can be used to mock dependencies and simulate HTTP requests.

  • Service Tests: Service tests verify the functionality of the service layer by testing the business logic and behavior of individual service methods. These tests typically involve creating test cases with different inputs and asserting the expected outputs. Mocking frameworks like Mockito can be used to mock dependencies and isolate the service being tested.

  • Data Access Tests: Data access tests focus on testing the DAO or repository layer and its interaction with the underlying data storage. These tests often use an in-memory database or stubs/mocks to simulate the data storage. The tests cover CRUD operations, data retrieval, and any query or transaction-related functionality.

By testing each layer independently, you can ensure the overall quality, correctness, and reliability of your API on App Engine. It helps identify bugs, validate the behavior of individual components, and provides confidence in the system's functionality.

Prerequisites

Before writing JUnit test cases for your APIs, make sure you have the following:

  1. Development Environment: Set up your development environment with Java and an integrated development environment (IDE) such as Eclipse or IntelliJ.

  2. JUnit Dependency: Include the JUnit dependency in your project's build configuration file (e.g., pom.xml for Maven projects).

Steps to Write JUnit Test Cases for APIs

Step 1: Identify the API Endpoint

Identify the API endpoint or method you want to test. Determine the input parameters, expected output, and any additional requirements or constraints.

Step 2: Set Up Test Environment

Create a new JUnit test class specifically for testing the API. Annotate the class with @RunWith(JUnitPlatform.class) to use the JUnit 5 platform.

Step 3: Write Test Methods

Create individual test methods within the test class to cover different scenarios or functionalities of the API. Each test method should be annotated with @Test to indicate that it is a test case.

Step 4: Prepare Test Data

If necessary, prepare any required test data or mock objects needed for the API test. This may involve creating sample input objects, mocking external dependencies, or setting up test databases.

Step 5: Invoke the API

Inside each test method, invoke the API endpoint or method being tested using the prepared test data or mock objects. Store the result or response for further validation.

Step 6: Validate the Results

Use assertions provided by the JUnit framework to validate the output or behavior of the API. Compare the actual results with the expected results to determine if the API is functioning correctly.

Step 7: Handle Exceptions and Error Cases

Handle any expected exceptions or error cases in your test methods using try-catch blocks or assertions. Verify that the API handles these scenarios appropriately and returns the expected errors or exceptions.

Step 8: Run the Tests

Execute the JUnit tests using your IDE or build tool. Review the test results to see if any tests fail or encounter errors. Investigate and fix any issues identified during the testing process.

 

Let's understand the above-mentioned point step by step with the help of the test case below:

  1. Set up the test environment:

    • Import the necessary JUnit classes:

      import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*;

    • Import LocalServiceTestHelper to access AppEngine service simulations locally.

      • import com.google.appengine.tools.development.testing.LocalServiceTestHelper; import com.google.appengine.tools.development.testing.LocalAppIdentityServiceTestConfig; import com.google.apphosting.api.ApiProxy;

    • Import the Mockito to use its functionalities.

      • import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when;

    • Create a test class and annotate it with @Test:

      class ContactEndPointTest { // Test methods will be written here }

       

    • Mock the related classes and Inject mock objects in the endpoint class that needs to be tested.

      // Create a mock HttpServletRequest HttpServletRequest request = mock(HttpServletRequest.class); // Create a mock HttpSession HttpSession httpSession = mock(HttpSession.class); @InjectMocks ContactEndPoint contactEndPoint; private final LocalServiceTestHelper testHelper = new LocalServiceTestHelper(new LocalAppIdentityServiceTestConfig());

       

    • Initialize all the mock objects.

      @BeforeEach public void setup() { MockitoAnnotations.initMocks(this); }

       

    • Establish database connection if needed and close after test cases are completed.

      @BeforeEach public void setup() { inMemoryDatabase = new InMemoryDatabase(); inMemoryDatabase.createTable(); MockitoAnnotations.initMocks(this); } @AfterEach public void tearDown() { inMemoryDatabase.dropTable(); inMemoryDatabase.closeConnection(); }

  2. Write test methods:

    • Create a test method and annotate it with @Test:

      @Test public void testSaveNewContactFailed() throws Exception { // Test logic will be written here }

  3. Prepare Test Data

    @Test final void testSaveNewContactFailed() throws Exception { when(request.getSession()).thenReturn(httpSession); when(httpSession.getAttribute(Constants.ACCOUNT_SLUG)).thenReturn(null); when(httpSession.getAttribute(Constants.ACCOUNT_ID)).thenReturn(accountId); when(httpSession.getAttribute(Constants.USER_EMAIL)).thenReturn(email); }

  4. Invoke the API

    @Test final void testSaveNewContactFailed() throws Exception { when(request.getSession()).thenReturn(httpSession); when(httpSession.getAttribute(Constants.ACCOUNT_SLUG)).thenReturn(null); when(httpSession.getAttribute(Constants.ACCOUNT_ID)).thenReturn(accountId); when(httpSession.getAttribute(Constants.USER_EMAIL)).thenReturn(email); when(mockContactService.saveNewContact(contacts, httpSession)).thenReturn(contacts); }

     

  5. Use assertions to verify expected outcomes:

    • Use JUnit's assertion methods, such as assertEquals(), assertTrue(), assertFalse(), etc., to verify the expected outcomes of your code.

    • For example, if you expect a method to return a specific value, you can use assertEquals():

      @Test final void testSaveNewContactFailed() throws Exception { when(request.getSession()).thenReturn(httpSession); when(httpSession.getAttribute(Constants.ACCOUNT_SLUG)).thenReturn(null); when(httpSession.getAttribute(Constants.ACCOUNT_ID)).thenReturn(accountId); when(httpSession.getAttribute(Constants.USER_EMAIL)).thenReturn(email); when(mockContactService.saveNewContact(contacts, httpSession)).thenReturn(contacts); assertNotNull(contact); }

  6. Handle Exceptions and Error

    @Test final void testSaveNewContactFailed() throws Exception { when(request.getSession()).thenReturn(httpSession); when(httpSession.getAttribute(Constants.ACCOUNT_SLUG)).thenReturn(null); when(httpSession.getAttribute(Constants.ACCOUNT_ID)).thenReturn(accountId); when(httpSession.getAttribute(Constants.USER_EMAIL)).thenReturn(email); when(mockContactService.saveNewContact(contacts, httpSession)).thenReturn(contacts); assertNotNull(contact); assertThrows(ApplicationException.class, () -> contactEndPoint.saveNewContact(user, httpServletRequest, contacts)); }

     

  7. Run the test:

    • Use an IDE to run your JUnit tests, right-click on the class and select coverage as an option, and then select JUnit 5. In most cases, you can right-click on the test class or the project and choose the option to run the tests using the JUnit icon.

    • The test runner will execute all the methods annotated with @Test and report the test results.

  8. Analyze the test results:

    • The test runner will provide feedback on the success or failure of each test method.

    • If a test fails, the runner will indicate which assertion failed and the expected vs. actual values.

  9. Refine and repeat:

    • If any test fails, analyze the failure and make necessary corrections to your code or test cases.

    • Re-run the tests to ensure the changes have resolved the issues.

    • Repeat this process until all tests pass and you have confidence in the correctness of your code.

 

To check the complete and actual test cases, check the repo: https://gitlab.com/eshopbox-team/inventoryengine-metadata

Conclusion

Writing JUnit test cases for APIs in Java is an essential part of the software development process. It helps ensure that your APIs function as expected and guards against regressions when making changes. By following the steps outlined in this document, you can effectively write JUnit test cases to validate the behavior and correctness of your APIs.

Related content