Added Unit Test Cases for Wrapper and Helper Files

src/test/java/com/salessparrow/api/unit/lib/salesforce/helper/MakeCompositeRequestTest.java

@@ -0,0 +1,60 @@
+package com.salessparrow.api.unit.lib.salesforce.helper;
+
+import com.salessparrow.api.lib.globalConstants.SalesforceConstants;
+import com.salessparrow.api.lib.httpLib.HttpClient;
+import com.salessparrow.api.lib.salesforce.dto.CompositeRequestDto;
+import com.salessparrow.api.lib.salesforce.helper.MakeCompositeRequest;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceRequest;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceRequestInterface;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+@SpringBootTest
+public class MakeCompositeRequestTest {
+
+	@Mock
+	private SalesforceRequest salesforceRequest;
+
+	@Mock
+	private SalesforceConstants salesforceConstants;
+
+	@InjectMocks
+	private MakeCompositeRequest makeCompositeRequest;
+
+	@BeforeEach
+	public void setUp() {
+		MockitoAnnotations.openMocks(this);
+	}
+
+	@Test
+	public void testMakePostRequest() {
+
+		List<CompositeRequestDto> compositeRequests = new ArrayList<>();
+		CompositeRequestDto requestDto = new CompositeRequestDto("endpoint", "method", null);
+		compositeRequests.add(requestDto);
+
+		when(salesforceConstants.timeoutMillis()).thenReturn(5000);
+
+		when(salesforceConstants.salesforceCompositeUrl(anyString())).thenReturn("composite_url");
+
+		when(salesforceRequest.makeRequest(anyString(), any(SalesforceRequestInterface.class)))
+			.thenReturn(new HttpClient.HttpResponse(200, "response", null, "application/json"));
+
+		HttpClient.HttpResponse response = makeCompositeRequest.makePostRequest(compositeRequests, "user_id");
+
+		assertEquals(200, response.getStatusCode());
+		assertEquals("response", response.getResponseBody());
+	}
+
+}

src/test/java/com/salessparrow/api/unit/lib/salesforce/helper/SalesforceOAuthTokenTest.java

@@ -0,0 +1,88 @@
+package com.salessparrow.api.unit.lib.salesforce.helper;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.salessparrow.api.domain.SalesforceOauthToken;
+import com.salessparrow.api.lib.AwsKms;
+import com.salessparrow.api.lib.Util;
+import com.salessparrow.api.lib.httpLib.HttpClient;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceOAuthToken;
+import com.salessparrow.api.lib.salesforce.wrappers.SalesforceGetRefreshedAccessToken;
+import com.salessparrow.api.repositories.SalesforceOauthTokenRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+public class SalesforceOAuthTokenTest {
+
+	@Mock
+	private AwsKms awsKms;
+
+	@Mock
+	private SalesforceOauthTokenRepository salesforceOauthTokenRepository;
+
+	@Mock
+	private SalesforceGetRefreshedAccessToken salesforceGetRefreshedAccessToken;
+
+	@Mock
+	private Util util;
+
+	@InjectMocks
+	private SalesforceOAuthToken salesforceOauthToken;
+
+	@BeforeEach
+	public void setUp() {
+		MockitoAnnotations.openMocks(this);
+	}
+
+	@Test
+	public void testFetchAccessToken() {
+
+		SalesforceOauthToken sfOAuthToken = new SalesforceOauthToken();
+		sfOAuthToken.setAccessToken("encrypted_access_token");
+
+		when(awsKms.decryptToken("encrypted_access_token")).thenReturn("decrypted_access_token");
+
+		String decryptedAccessToken = salesforceOauthToken.fetchAccessToken(sfOAuthToken);
+
+		assertEquals("decrypted_access_token", decryptedAccessToken);
+	}
+
+	@Test
+	public void testUpdateAndGetRefreshedAccessToken() throws Exception {
+
+		SalesforceOauthToken sfOAuthToken = new SalesforceOauthToken();
+		sfOAuthToken.setRefreshToken("encrypted_refresh_token");
+
+		String responseBody = "{\"access_token\":\"new_access_token\"}";
+		ObjectMapper map = new ObjectMapper();
+		JsonNode responseBodyNode = map.readTree(responseBody);
+
+		when(awsKms.decryptToken("encrypted_refresh_token")).thenReturn("decrypted_refresh_token");
+
+		HttpClient.HttpResponse response = new HttpClient.HttpResponse(200, responseBody, null, "application/json");
+		when(salesforceGetRefreshedAccessToken.getRefreshedAccessToken("decrypted_refresh_token")).thenReturn(response);
+
+		when(util.getJsonNode(responseBody)).thenReturn(responseBodyNode);
+
+		when(awsKms.encryptToken("new_access_token")).thenReturn("encrypted_access_token");
+
+		when(salesforceOauthTokenRepository.updateSalesforceOauthToken(any(SalesforceOauthToken.class)))
+			.thenAnswer(invocation -> invocation.getArgument(0)); // Return the argument
+																	// back
+
+		String decryptedAccessToken = salesforceOauthToken.updateAndGetRefreshedAccessToken(sfOAuthToken);
+
+		assertEquals("new_access_token", decryptedAccessToken);
+		assertEquals(200, response.getStatusCode());
+		assertTrue(responseBodyNode.has("access_token"));
+	}
+
+}

src/test/java/com/salessparrow/api/unit/lib/salesforce/helper/SalesforceRequestTest.java

@@ -0,0 +1,121 @@
+package com.salessparrow.api.unit.lib.salesforce.helper;
+
+import com.salessparrow.api.domain.SalesforceOauthToken;
+import com.salessparrow.api.exception.CustomException;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceOAuthToken;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceRequest;
+import com.salessparrow.api.lib.salesforce.helper.SalesforceRequestInterface;
+import com.salessparrow.api.repositories.SalesforceOauthTokenRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.web.reactive.function.client.WebClientResponseException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@SpringBootTest
+public class SalesforceRequestTest {
+
+	@Mock
+	private SalesforceOAuthToken salesforceOAuthToken;
+
+	@Mock
+	private SalesforceOauthTokenRepository sfOauthTokenRepository;
+
+	@InjectMocks
+	private SalesforceRequest salesforceRequest;
+
+	@BeforeEach
+	public void setUp() {
+		MockitoAnnotations.openMocks(this);
+	}
+
+	@Test
+	public void testMakeRequestSuccess() {
+
+		SalesforceOauthToken sfOAuthToken = new SalesforceOauthToken();
+		sfOAuthToken.setAccessToken("access_token");
+		sfOAuthToken.setInstanceUrl("https://instance.url");
+
+		when(sfOauthTokenRepository.getSalesforceOauthTokenByExternalUserId("user123")).thenReturn(sfOAuthToken);
+
+		// Mock SalesforceOAuthToken
+		when(salesforceOAuthToken.fetchAccessToken(any(SalesforceOauthToken.class))).thenReturn("access_token");
+
+		// Mock SalesforceRequestInterface
+		SalesforceRequestInterface<String> requestInterface = (token, instanceUrl) -> "Response";
+
+		// Test the method
+		String response = salesforceRequest.makeRequest("user123", requestInterface);
+
+		// Verify that the methods were called with the expected parameters
+		verify(sfOauthTokenRepository).getSalesforceOauthTokenByExternalUserId("user123");
+		verify(salesforceOAuthToken).fetchAccessToken(sfOAuthToken);
+
+		// Verify the response
+		assertEquals("Response", response);
+	}
+
+	@Test
+	public void testMakeRequestWebClientResponseException() {
+
+		SalesforceOauthToken sfOAuthToken = new SalesforceOauthToken();
+		sfOAuthToken.setAccessToken("access_token");
+		sfOAuthToken.setInstanceUrl("https://instance.url");
+
+		when(sfOauthTokenRepository.getSalesforceOauthTokenByExternalUserId("user123")).thenReturn(sfOAuthToken);
+
+		// Mock SalesforceOAuthToken
+		when(salesforceOAuthToken.fetchAccessToken(any(SalesforceOauthToken.class))).thenReturn("access_token");
+
+		// Mock SalesforceRequestInterface
+		SalesforceRequestInterface<String> requestInterface = (token, instanceUrl) -> {
+			throw new WebClientResponseException(401, "Unauthorized", null, null, null);
+		};
+
+		// Test the method and expect a CustomException
+		assertThrows(CustomException.class, () -> salesforceRequest.makeRequest("user123", requestInterface));
+
+		// Verify that the methods were called with the expected parameters
+		verify(sfOauthTokenRepository).getSalesforceOauthTokenByExternalUserId("user123");
+		verify(salesforceOAuthToken).fetchAccessToken(sfOAuthToken);
+
+		// Verify that the updateAndGetRefreshedAccessToken method was called once
+		verify(salesforceOAuthToken, times(1)).updateAndGetRefreshedAccessToken(sfOAuthToken);
+	}
+
+	@Test
+	public void testMakeRequestInternalServerErrorException() {
+
+		SalesforceOauthToken sfOAuthToken = new SalesforceOauthToken();
+		sfOAuthToken.setAccessToken("access_token");
+		sfOAuthToken.setInstanceUrl("https://instance.url");
+
+		when(sfOauthTokenRepository.getSalesforceOauthTokenByExternalUserId("user123")).thenReturn(sfOAuthToken);
+
+		// Mock SalesforceOAuthToken
+		when(salesforceOAuthToken.fetchAccessToken(any(SalesforceOauthToken.class))).thenReturn("access_token");
+
+		// Mock SalesforceRequestInterface
+		SalesforceRequestInterface<String> requestInterface = (token, instanceUrl) -> {
+			throw new WebClientResponseException(500, "Internal Server Error", null, null, null);
+		};
+
+		// Test the method and expect a CustomException
+		assertThrows(CustomException.class, () -> salesforceRequest.makeRequest("user123", requestInterface));
+
+		// Verify that the methods were called with the expected parameters
+		verify(sfOauthTokenRepository).getSalesforceOauthTokenByExternalUserId("user123");
+		verify(salesforceOAuthToken).fetchAccessToken(sfOAuthToken);
+
+		// Verify that the updateAndGetRefreshedAccessToken method was not called
+		verify(salesforceOAuthToken, never()).updateAndGetRefreshedAccessToken(sfOAuthToken);
+	}
+
+}

src/test/java/com/salessparrow/api/unit/lib/salesforce/wrappers/SalesforceGetIdentityTest.java

@@ -0,0 +1,99 @@
+package com.salessparrow.api.unit.lib.salesforce.wrappers;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.beans.factory.annotation.Autowired;
+import com.salessparrow.api.exception.CustomException;
+import com.salessparrow.api.lib.errorLib.ErrorObject;
+import com.salessparrow.api.lib.globalConstants.SalesforceConstants;
+import com.salessparrow.api.lib.httpLib.HttpClient;
+import com.salessparrow.api.lib.httpLib.HttpClient.HttpResponse;
+import com.salessparrow.api.lib.salesforce.wrappers.SalesforceGetIdentity;
+
+@SpringBootTest
+@Import({ SalesforceGetIdentity.class, SalesforceConstants.class })
+public class SalesforceGetIdentityTest {
+
+	@Autowired
+	private SalesforceGetIdentity salesforceGetIdentity;
+
+	@Autowired
+	private SalesforceConstants salesforceConstants;
+
+	@Test
+	public void testGetUserIdentitySuccess() throws Exception {
+		try (MockedStatic<HttpClient> httpClientMockedStatic = Mockito.mockStatic(HttpClient.class)) {
+
+			String instanceUrl = "https://example.com";
+			String accessToken = "dummyAccessToken";
+
+			Map<String, String> headers = new HashMap<>();
+			headers.put("Authorization", "Bearer " + accessToken);
+
+			String responseBody = "Mock Response Body";
+			HttpResponse mockResponse = new HttpResponse();
+			mockResponse.setResponseBody(responseBody);
+
+			httpClientMockedStatic.when(() -> HttpClient.makeGetRequest(anyString(), anyMap(), anyInt()))
+				.thenReturn(mockResponse);
+
+			HttpResponse actualResponse = salesforceGetIdentity.getUserIdentity(instanceUrl, accessToken);
+
+			// Assertions
+			assertEquals(mockResponse.getResponseBody(), actualResponse.getResponseBody());
+
+			httpClientMockedStatic.verify(
+					() -> HttpClient.makeGetRequest(instanceUrl + salesforceConstants.identityUrl(), headers, 10000),
+					Mockito.times(1));
+		}
+	}
+
+	@Test
+	public void testGetUserIdentityException() throws Exception {
+		try (MockedStatic<HttpClient> httpClientMockedStatic = Mockito.mockStatic(HttpClient.class)) {
+
+			String instanceUrl = "https://example.com";
+			String accessToken = "dummyAccessToken";
+
+			Map<String, String> headers = new HashMap<>();
+			headers.put("Authorization", "Bearer " + accessToken);
+
+			String responseBody = "Mock Response Body";
+			HttpResponse mockResponse = new HttpResponse();
+			mockResponse.setResponseBody(responseBody);
+
+			httpClientMockedStatic.when(() -> HttpClient.makeGetRequest(anyString(), anyMap(), anyInt()))
+				.thenThrow(new RuntimeException("Some error occurred"));
+
+			CustomException exception = assertThrows(CustomException.class, () -> {
+				salesforceGetIdentity.getUserIdentity(instanceUrl, accessToken);
+			});
+
+			// Assertions
+			assertNotNull(exception);
+			ErrorObject errorObject = exception.getErrorObject();
+			assertNotNull(errorObject);
+			assertEquals("l_s_w_sgi_gui_1", errorObject.getInternalErrorIdentifier());
+			assertEquals("bad_request", errorObject.getApiErrorIdentifier());
+
+			httpClientMockedStatic.verify(
+					() -> HttpClient.makeGetRequest(instanceUrl + salesforceConstants.identityUrl(), headers, 10000),
+					Mockito.times(1));
+
+		}
+	}
+
+}