diff --git a/pom.xml b/pom.xml
index 34b80ea..b13edb5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -72,6 +72,12 @@
 <!--			<artifactId>kernel-auth-adapter</artifactId>-->
 <!--			<version>1.2.1-SNAPSHOT</version>-->
 <!--		</dependency>-->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.13.2</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.junit.vintage</groupId>
 			<artifactId>junit-vintage-engine</artifactId>
diff --git a/src/main/java/DigitalCardControllerTest.java b/src/main/java/DigitalCardControllerTest.java
new file mode 100644
index 0000000..2c7a49d
--- /dev/null
+++ b/src/main/java/DigitalCardControllerTest.java
@@ -0,0 +1,102 @@
+package io.mosip.digitalcard.test.controller;
+
+import io.mosip.digitalcard.controller.DigitalCardController;
+import io.mosip.digitalcard.dto.DataShareResponseDto;
+import io.mosip.digitalcard.dto.DigitalCardStatusResponseDto;
+import io.mosip.digitalcard.service.DigitalCardService;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.kernel.core.http.ResponseWrapper;
+import io.mosip.kernel.core.websub.model.Event;
+import io.mosip.kernel.core.websub.model.EventModel;
+import io.mosip.kernel.core.websub.model.Type;
+import org.jetbrains.annotations.NotNull;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import java.util.HashMap;
+import java.util.Map;
+import org.springframework.core.env.Environment;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+import static org.springframework.test.util.AssertionErrors.assertEquals;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class DigitalCardControllerTest {
+    @InjectMocks
+    private DigitalCardController digitalCardController;
+    @Mock
+    private DigitalCardService digitalCardService;
+    @Mock
+    private Environment environment;
+    @Test
+    public void handleIdentityCreateEventTest(){
+        EventModel eventModel = getEventModel();
+        doNothing().when(digitalCardService).initiateCredentialRequest(anyString(), anyString());
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityCreateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+
+    @Test
+    public void testHandleIdentityUpdateEvent_Success() {
+        EventModel eventModel = getEventModel();
+        doNothing().when(digitalCardService).initiateCredentialRequest(anyString(), anyString());
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityUpdateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+    @Test
+    public void testHandleIdentityUpdateEvent_Exception() {
+        EventModel eventModel = getEventModel();
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityUpdateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+
+    @NotNull
+    private static EventModel getEventModel() {
+        EventModel eventModel=new EventModel();
+        Event event=new Event();
+        event.setId("113534");
+        Type type=new Type();
+        type.setName("rwctw");
+        type.setNamespace("huea");
+        Map<String, Object> data = new HashMap<>();
+        data.put("registration_id", "test_registration_id");
+        data.put("id_hash", "test_id_hash");
+        event.setData(data);
+        event.setType(type);
+        event.setTimestamp("211");
+        event.setTransactionId("edfvgghdfghjdfghj");
+        event.setDataShareUri("dfgwyyw");
+        eventModel.setEvent(event);
+        eventModel.setPublisher("ytft");
+        eventModel.setPublishedOn("yguygyug");
+        eventModel.setTopic("fgwqdtwdqv");
+        return eventModel;
+    }
+    @Test
+    public void credentialEventTest(){
+        EventModel eventModel = getEventModel();
+        ResponseEntity<?> responseEntity = digitalCardController.credentialEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+    @Test
+    public void getDigitalCardTest(){
+        String rid = "123456";
+        DigitalCardStatusResponseDto digitalCardStatusResponseDto = new DigitalCardStatusResponseDto();
+        digitalCardStatusResponseDto.setStatusCode("123");
+        digitalCardStatusResponseDto.setUrl("url");
+        digitalCardStatusResponseDto.setId("id_121");
+        ResponseWrapper<DigitalCardStatusResponseDto> expectedResponse = new DataShareResponseDto();
+        expectedResponse.setResponse(digitalCardStatusResponseDto);
+        when(digitalCardService.getDigitalCard(rid)).thenReturn(digitalCardStatusResponseDto);
+        ResponseWrapper<DigitalCardStatusResponseDto> actualResponse = digitalCardController.getDigitalCard(rid);
+        assertEquals(expectedResponse.getResponse().getId(), actualResponse.getResponse().getStatusCode(), expectedResponse.getResponse().getStatusCode());
+    }
+}
\ No newline at end of file
diff --git a/src/test/test/java/io/mosip/digitalcard/test/TestBootApplication.java b/src/test/test/java/io/mosip/digitalcard/test/TestBootApplication.java
new file mode 100644
index 0000000..b810dc0
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/TestBootApplication.java
@@ -0,0 +1,19 @@
+package io.mosip.digitalcard.test;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.scheduling.annotation.EnableAsync;
+
+
+@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })
+
+@EnableAsync
+@EnableCaching
+public class TestBootApplication {
+
+public static void main(String... args) {
+    SpringApplication.run(TestBootApplication.class, args);
+}
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/config/SchedulingConfigurerConfigurationTest.java b/src/test/test/java/io/mosip/digitalcard/test/config/SchedulingConfigurerConfigurationTest.java
new file mode 100644
index 0000000..7830f14
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/config/SchedulingConfigurerConfigurationTest.java
@@ -0,0 +1,33 @@
+package io.mosip.digitalcard.test.config;
+
+import io.mosip.digitalcard.config.SchedulingConfigurerConfiguration;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+import org.springframework.scheduling.config.ScheduledTaskRegistrar;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SchedulingConfigurerConfigurationTest {
+
+    @InjectMocks
+    private SchedulingConfigurerConfiguration schedulingConfigurerConfiguration;
+
+    @Mock
+    private ScheduledTaskRegistrar taskRegistrar;
+
+    @Test
+    public void testConfigureTasks() {
+        schedulingConfigurerConfiguration.configureTasks(taskRegistrar);
+
+        verify(taskRegistrar, times(1)).setTaskScheduler(any(ThreadPoolTaskScheduler.class));
+
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/controller/DigitalCardControllerTest.java b/src/test/test/java/io/mosip/digitalcard/test/controller/DigitalCardControllerTest.java
new file mode 100644
index 0000000..80cd3ab
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/controller/DigitalCardControllerTest.java
@@ -0,0 +1,98 @@
+package io.mosip.digitalcard.test.controller;
+
+import io.mosip.digitalcard.controller.DigitalCardController;
+import io.mosip.digitalcard.dto.DataShareResponseDto;
+import io.mosip.digitalcard.dto.DigitalCardStatusResponseDto;
+import io.mosip.digitalcard.service.DigitalCardService;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.kernel.core.http.ResponseWrapper;
+import io.mosip.kernel.core.websub.model.Event;
+import io.mosip.kernel.core.websub.model.EventModel;
+import io.mosip.kernel.core.websub.model.Type;
+import jakarta.validation.constraints.NotNull;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+import static org.springframework.test.util.AssertionErrors.assertEquals;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class DigitalCardControllerTest {
+
+    @InjectMocks
+    private DigitalCardController digitalCardController;
+
+    @Mock
+    private DigitalCardService digitalCardService;
+
+    @Test
+    public void handleIdentityCreateEventTest(){
+        EventModel eventModel = getEventModel();
+        doNothing().when(digitalCardService).initiateCredentialRequest(anyString(), anyString());
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityCreateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+
+    @Test
+    public void testHandleIdentityUpdateEvent_Success() {
+        EventModel eventModel = getEventModel();
+        doNothing().when(digitalCardService).initiateCredentialRequest(anyString(), anyString());
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityUpdateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+
+    @Test
+    public void testHandleIdentityUpdateEvent_Exception() {
+        EventModel eventModel = getEventModel();
+        ResponseEntity<?> responseEntity = digitalCardController.handleIdentityUpdateEvent(eventModel);
+        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
+    }
+
+    @NotNull
+    private static EventModel getEventModel() {
+        EventModel eventModel=new EventModel();
+        Event event=new Event();
+        event.setId("113534");
+        Type type=new Type();
+        type.setName("rwctw");
+        type.setNamespace("huea");
+        Map<String, Object> data = new HashMap<>();
+        data.put("registration_id", "test_registration_id");
+        data.put("id_hash", "test_id_hash");
+        event.setData(data);
+        event.setType(type);
+        event.setTimestamp("211");
+        event.setTransactionId("edfvgghdfghjdfghj");
+        event.setDataShareUri("dfgwyyw");
+        eventModel.setEvent(event);
+        eventModel.setPublisher("ytft");
+        eventModel.setPublishedOn("yguygyug");
+        eventModel.setTopic("fgwqdtwdqv");
+        return eventModel;
+    }
+
+    @Test
+    public void getDigitalCardTest(){
+        String rid = "123456";
+        DigitalCardStatusResponseDto digitalCardStatusResponseDto = new DigitalCardStatusResponseDto();
+        digitalCardStatusResponseDto.setStatusCode("123");
+        digitalCardStatusResponseDto.setUrl("url");
+        digitalCardStatusResponseDto.setId("id_121");
+        ResponseWrapper<DigitalCardStatusResponseDto> expectedResponse = new DataShareResponseDto();
+        expectedResponse.setResponse(digitalCardStatusResponseDto);
+        when(digitalCardService.getDigitalCard(rid)).thenReturn(digitalCardStatusResponseDto);
+        ResponseWrapper<DigitalCardStatusResponseDto> actualResponse = digitalCardController.getDigitalCard(rid);
+        assertEquals(expectedResponse.getResponse().getId(), actualResponse.getResponse().getStatusCode(), expectedResponse.getResponse().getStatusCode());
+    }
+}
\ No newline at end of file
diff --git a/src/test/test/java/io/mosip/digitalcard/test/exception/ApiExceptionHandlerTest.java b/src/test/test/java/io/mosip/digitalcard/test/exception/ApiExceptionHandlerTest.java
new file mode 100644
index 0000000..31e9f35
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/exception/ApiExceptionHandlerTest.java
@@ -0,0 +1,143 @@
+package io.mosip.digitalcard.test.exception;
+
+import io.mosip.digitalcard.constant.AuthAdapterErrorCode;
+import io.mosip.digitalcard.constant.DigitalCardServiceErrorCodes;
+import io.mosip.digitalcard.exception.ApiExceptionHandler;
+import io.mosip.digitalcard.exception.DataNotFoundException;
+import io.mosip.digitalcard.exception.DigitalCardServiceException;
+import io.mosip.kernel.core.authmanager.exception.AuthNException;
+import io.mosip.kernel.core.authmanager.exception.AuthZException;
+import jakarta.servlet.http.HttpServletRequest;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import io.mosip.kernel.core.exception.ServiceError;
+import io.mosip.kernel.core.http.ResponseWrapper;
+
+import org.junit.runner.RunWith;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.AccessDeniedException;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.powermock.api.mockito.PowerMockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ApiExceptionHandlerTest {
+
+    @InjectMocks
+    private ApiExceptionHandler apiExceptionHandler;
+
+    @Test
+    public void controlDataNotFoundExceptionTest()throws IOException {
+        ResponseEntity<ResponseWrapper<ServiceError>> actualControlDataServiceExceptionResult = apiExceptionHandler
+                .controlDataNotFoundException(null, new DataNotFoundException("DCS-408","PDF not found"));
+        assertTrue(actualControlDataServiceExceptionResult.hasBody());
+        assertTrue(actualControlDataServiceExceptionResult.getHeaders().isEmpty());
+        assertEquals(HttpStatus.OK, actualControlDataServiceExceptionResult.getStatusCode());
+        List<ServiceError> errors = actualControlDataServiceExceptionResult.getBody().getErrors();
+        assertEquals(1, errors.size());
+        ServiceError getResult = errors.get(0);
+        assertEquals("DCS-408", getResult.getErrorCode());
+        assertEquals("PDF not found", getResult.getMessage());
+    }
+
+    @Test
+    public void controlDataNotFoundExceptionTest1()throws IOException {
+        ResponseEntity<ResponseWrapper<ServiceError>> actualControlDataServiceExceptionResult = apiExceptionHandler
+                .controlDataNotFoundException(null, new DigitalCardServiceException("DCS-408","PDF not found"));
+        assertTrue(actualControlDataServiceExceptionResult.hasBody());
+        assertTrue(actualControlDataServiceExceptionResult.getHeaders().isEmpty());
+        assertEquals(HttpStatus.OK, actualControlDataServiceExceptionResult.getStatusCode());
+        List<ServiceError> errors = actualControlDataServiceExceptionResult.getBody().getErrors();
+        assertEquals(1, errors.size());
+        ServiceError getResult = errors.get(0);
+        assertEquals("DCS-011", getResult.getErrorCode());
+        assertEquals("PDF not found", getResult.getMessage());
+    }
+
+    @Test
+    public void testOnAccessDeniedException() throws IOException {
+        HttpServletRequest httpServletRequest = mock(HttpServletRequest.class);
+        AccessDeniedException accessDeniedException = new AccessDeniedException("Access denied");
+        ResponseEntity<ResponseWrapper<ServiceError>> responseEntity = apiExceptionHandler.onAccessDeniedException(httpServletRequest, accessDeniedException);
+
+        assertEquals(HttpStatus.FORBIDDEN, responseEntity.getStatusCode());
+
+        ResponseWrapper<ServiceError> responseBody = responseEntity.getBody();
+        assertNotNull(responseBody);
+        assertNotNull(responseBody.getErrors());
+        assertEquals(1, responseBody.getErrors().size());
+
+        ServiceError serviceError = responseBody.getErrors().get(0);
+        assertEquals(AuthAdapterErrorCode.FORBIDDEN.getErrorCode(), serviceError.getErrorCode());
+    }
+
+    @Test
+    public void testOnAuthZException() throws IOException {
+        HttpServletRequest httpServletRequest = mock(HttpServletRequest.class);
+
+        List<ServiceError> serviceErrors = new ArrayList<>();
+        serviceErrors.add(new ServiceError(AuthAdapterErrorCode.FORBIDDEN.getErrorCode(),
+                AuthAdapterErrorCode.FORBIDDEN.getErrorMessage()));
+
+        AuthZException authZException = new AuthZException(serviceErrors);
+
+        ResponseEntity<ResponseWrapper<ServiceError>> responseEntity = apiExceptionHandler.onAuthZException(httpServletRequest, authZException);
+
+        assertEquals(HttpStatus.FORBIDDEN, responseEntity.getStatusCode());
+
+        ResponseWrapper<ServiceError> responseBody = responseEntity.getBody();
+        assertNotNull(responseBody);
+        assertNotNull(responseBody.getErrors());
+        assertEquals(1, responseBody.getErrors().size());
+
+        ServiceError serviceError = responseBody.getErrors().get(0);
+        assertEquals(AuthAdapterErrorCode.FORBIDDEN.getErrorCode(), serviceError.getErrorCode());
+    }
+
+    @Test
+    public void testOnAuthNException() throws IOException {
+        HttpServletRequest httpServletRequest = mock(HttpServletRequest.class);
+        List<ServiceError> serviceErrors = new ArrayList<>();
+        serviceErrors.add(new ServiceError(AuthAdapterErrorCode.UNAUTHORIZED.getErrorCode(),
+                AuthAdapterErrorCode.UNAUTHORIZED.getErrorMessage()));
+
+        AuthNException authNException = new AuthNException(serviceErrors);
+
+        ResponseEntity<ResponseWrapper<ServiceError>> responseEntity = apiExceptionHandler.onAuthNException(httpServletRequest, authNException);
+
+        assertEquals(HttpStatus.UNAUTHORIZED, responseEntity.getStatusCode());
+
+        ResponseWrapper<ServiceError> responseBody = responseEntity.getBody();
+        assertNotNull(responseBody);
+        assertNotNull(responseBody.getErrors());
+        assertEquals(1, responseBody.getErrors().size());
+
+        ServiceError serviceError = responseBody.getErrors().get(0);
+        assertEquals(AuthAdapterErrorCode.UNAUTHORIZED.getErrorCode(), serviceError.getErrorCode());
+    }
+
+    @Test
+    public void testDefaultErrorHandler() throws IOException {
+        HttpServletRequest httpServletRequest = mock(HttpServletRequest.class);
+        Exception exception = new Exception("An unexpected error occurred");
+        ResponseEntity<ResponseWrapper<ServiceError>> responseEntity = apiExceptionHandler.defaultErrorHandler(httpServletRequest, exception);
+
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+
+        ResponseWrapper<ServiceError> responseBody = responseEntity.getBody();
+        assertNotNull(responseBody);
+        assertNotNull(responseBody.getErrors());
+        assertEquals(1, responseBody.getErrors().size());
+
+        ServiceError serviceError = responseBody.getErrors().get(0);
+        assertEquals(DigitalCardServiceErrorCodes.DIGITAL_CARD_NOT_GENERATED.getErrorCode(), serviceError.getErrorCode());
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/service/DigitalCardServiceTest.java b/src/test/test/java/io/mosip/digitalcard/test/service/DigitalCardServiceTest.java
new file mode 100644
index 0000000..ea326af
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/service/DigitalCardServiceTest.java
@@ -0,0 +1,320 @@
+package io.mosip.digitalcard.test.service;
+
+import io.mosip.digitalcard.constant.DigitalCardServiceErrorCodes;
+import io.mosip.digitalcard.controller.DigitalCardController;
+import io.mosip.digitalcard.dto.*;
+import io.mosip.digitalcard.entity.DigitalCardTransactionEntity;
+import io.mosip.digitalcard.exception.DigitalCardServiceException;
+import io.mosip.digitalcard.repositories.DigitalCardTransactionRepository;
+import io.mosip.digitalcard.service.CardGeneratorService;
+import io.mosip.digitalcard.service.impl.DigitalCardServiceImpl;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.digitalcard.util.*;
+import io.mosip.digitalcard.websub.WebSubSubscriptionHelper;
+import io.mosip.kernel.core.logger.spi.Logger;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.json.JSONObject;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import org.springframework.test.util.ReflectionTestUtils;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class DigitalCardServiceTest {
+
+    @InjectMocks
+    DigitalCardServiceImpl digitalCardService;
+
+    @Mock
+    private EncryptionUtil encryptionUtil;
+
+    @Mock
+    private DigitalCardTransactionRepository digitalCardTransactionRepository;
+
+    @Mock
+    private CredentialUtil credentialUtil;
+
+    @Mock
+    private WebSubSubscriptionHelper webSubSubscriptionHelper;
+
+    @Mock
+    Logger logger = DigitalCardRepoLogger.getLogger(DigitalCardController.class);
+
+    @Mock
+    private CardGeneratorService pdfCardServiceImpl;
+
+    @Mock
+    private DataShareUtil dataShareUtil;
+    private String rid = "testRid";
+    private String partnerId = "partnerId";
+    private String credentialType = "credentialType";
+    private boolean isInitiateFlag = true;
+    @Value("${mosip.digitalcard.datashare.policy.id}")
+    private String dataSharePolicyId;
+    @Value("${mosip.digitalcard.datashare.partner.id}")
+    private String dataSharePartnerId;
+    @Value("${mosip.digitalcard.websub.publish.topic:CREDENTIAL_STATUS_UPDATE}")
+    private String topic;
+    @Value("${mosip.digitalcard.uincard.password}")
+    private String digitalCardPassword;
+
+    @Test
+    public void generateDigitalCardTest() throws Exception {
+        String credential="encryptedCredential";
+        String credentialType="c_type";
+        String eventId="54154f54";
+        String transactionId="de5fefe673r";
+        Map<String, Object> additionalAttributes = new HashMap<>();
+
+        boolean verifyCredentialsFlag = false;
+        boolean isPasswordProtected = true;
+
+        String decryptedCredential = "{ \"credentialSubject\": { \"id\": \"12345\" } }";
+        JSONObject jsonObject = new JSONObject(decryptedCredential);
+        JSONObject decryptedCredentialJson = jsonObject.getJSONObject("credentialSubject");
+        System.out.println(decryptedCredentialJson);
+        byte[] pdfBytes = new byte[]{1, 2, 3};
+
+        ReflectionTestUtils.setField(digitalCardService, "verifyCredentialsFlag", verifyCredentialsFlag);
+        ReflectionTestUtils.setField(digitalCardService, "isPasswordProtected", isPasswordProtected);
+
+        DigitalCardServiceException exception = assertThrows(DigitalCardServiceException.class, () -> {
+            ReflectionTestUtils.invokeMethod(digitalCardService, "generateDigitalCard", credential, credentialType, null, eventId, transactionId, additionalAttributes);
+        });
+
+        assertEquals("DCS-011 --> Error while generating PDF for Digital Card", exception.getMessage());
+        assertEquals(DigitalCardServiceErrorCodes.DATASHARE_EXCEPTION.getErrorCode()+" --> "+DigitalCardServiceErrorCodes.DIGITAL_CARD_NOT_GENERATED.getErrorMessage(), exception.getMessage());
+        try {
+            digitalCardService.generateDigitalCard(credential, credentialType, null, eventId, transactionId, additionalAttributes);
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testGenerateDigitalCard_Failure_VerificationFailed() throws Exception {
+        String credential = "encryptedCredential";
+        String decryptedCredential = "{ \"credentialSubject\": { \"id\": \"12345\" } }";
+        String credentialType = "someType";
+        String dataShareUrl = null;
+        String eventId = "eventId";
+        String transactionId = "transactionId";
+        Map<String, Object> additionalAttributes = new HashMap<>();
+
+        when(encryptionUtil.decryptData(credential)).thenReturn(decryptedCredential);
+
+        JSONObject jsonObject = new JSONObject(decryptedCredential);
+        JSONObject decryptedCredentialJson = jsonObject.getJSONObject("credentialSubject");
+
+        assertThrows(DigitalCardServiceException.class, () -> {
+            ReflectionTestUtils.invokeMethod(digitalCardService, "generateDigitalCard", credential, credentialType, dataShareUrl, eventId, transactionId, additionalAttributes);
+        });
+
+        verify(pdfCardServiceImpl, never()).generateCard(any(), anyString(), anyString(), anyMap());
+        verify(webSubSubscriptionHelper, never()).digitalCardStatusUpdateEvent(anyString(), any());
+    }
+
+    @Test
+    public void testGetDigitalCard_Success() {
+        DigitalCardTransactionEntity entity = new DigitalCardTransactionEntity();
+        entity.setrid(rid);
+        entity.setStatusCode("200");
+        entity.setDataShareUrl("http://example.com");
+
+        when(digitalCardTransactionRepository.findByRID(rid)).thenReturn(entity);
+
+        DigitalCardStatusResponseDto response = digitalCardService.getDigitalCard(rid);
+
+        assertNotNull(response);
+        assertEquals(rid, response.getId());
+        assertEquals("200", response.getStatusCode());
+        assertEquals("http://example.com", response.getUrl());
+    }
+
+    private void setPrivateField(Object target, String fieldName, Object value) throws Exception {
+        Field field = target.getClass().getDeclaredField(fieldName);
+        ((Field) field).setAccessible(true);
+        field.set(target, value);
+    }
+
+    @Test
+    public void testGetDigitalCard_InitiateFlagTrue() throws Exception {
+        setPrivateField(digitalCardService, "isInitiateFlag", true);
+
+        when(digitalCardTransactionRepository.findByRID(rid)).thenReturn(null);
+
+        CredentialResponse credentialResponse = new CredentialResponse();
+
+        when(credentialUtil.reqCredential(any(CredentialRequestDto.class))).thenReturn(credentialResponse);
+
+        try {
+            digitalCardService.getDigitalCard(rid);
+            fail("Expected DigitalCardServiceException");
+        } catch (DigitalCardServiceException e) {
+            assertEquals(DigitalCardServiceErrorCodes.DATASHARE_EXCEPTION.getErrorCode(), e.getErrorCode());
+        }
+
+        verify(credentialUtil).reqCredential(any(CredentialRequestDto.class));
+    }
+
+    @Test(expected = DigitalCardServiceException.class)
+    public void testInitiateCredentialRequest_DigitalCardServiceException() throws Exception {
+        String rid = "testRid";
+        String ridHash = "testRidHash";
+
+        when(credentialUtil.reqCredential(any(CredentialRequestDto.class))).thenThrow(new DigitalCardServiceException("Error"));
+
+        digitalCardService.initiateCredentialRequest(rid, ridHash);
+        verify(logger).error(anyString(), any(DigitalCardServiceException.class));
+    }
+
+    @Test
+    public void saveTransactionDetailsTest() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        CredentialResponse credentialResponse=new CredentialResponse();
+        credentialResponse.setId("45564");
+        credentialResponse.setRequestId("ft656ft");
+        String idHash="id_hash";
+        String rid = "mockedRid";
+
+        DigitalCardTransactionEntity digitalCardEntity=new DigitalCardTransactionEntity();
+        digitalCardEntity.setrid(rid);
+        digitalCardEntity.setrid(credentialResponse.getId());
+        digitalCardEntity.setUinSaltedHash(idHash);
+        digitalCardEntity.setCredentialId(credentialResponse.getRequestId());
+        digitalCardEntity.setCreateDateTime(LocalDateTime.now());
+        digitalCardEntity.setCreatedBy(Utility.getUser());
+        digitalCardEntity.setStatusCode("NEW");
+
+        Method saveTransactionDetailsMethod = DigitalCardServiceImpl.class.getDeclaredMethod("saveTransactionDetails", CredentialResponse.class, String.class);
+        ((Method) saveTransactionDetailsMethod).setAccessible(true);
+
+        saveTransactionDetailsMethod.invoke(digitalCardService, credentialResponse, idHash);
+    }
+
+    @Test
+    public void testDigitalCardStatusUpdate_NewTransaction() throws Exception {
+        byte[] data = new byte[]{1, 2, 3, 4};
+        String dataSharePolicyId="mpolicy-default-digitalcard";
+        String dataSharePartnerId="mpartner-default-digitalcard";
+        String requestId = UUID.randomUUID().toString();
+        String credentialType = "credentialType";
+        String rid = "sampleRID";
+        String topic = "sampleTopic";
+
+        ReflectionTestUtils.setField(digitalCardService, "dataSharePolicyId", dataSharePolicyId);
+        ReflectionTestUtils.setField(digitalCardService, "dataSharePartnerId", dataSharePartnerId);
+
+        DataShareDto dataShareDto = new DataShareDto();
+        dataShareDto.setUrl("https://gsjdg");
+        dataShareDto.setSignature("sign");
+        dataShareDto.setValidForInMinutes(5);
+        dataShareDto.setPolicyId("P121313");
+        dataShareDto.setSubscriberId("SUB123");
+        dataShareDto.setTransactionsAllowed(10);
+
+        DigitalCardTransactionEntity digitalCardTransactionEntity = new DigitalCardTransactionEntity();
+        digitalCardTransactionEntity.setrid(rid);
+        digitalCardTransactionEntity.setCreateDateTime(LocalDateTime.now());
+        digitalCardTransactionEntity.setCreatedBy("testUser");
+        digitalCardTransactionEntity.setDataShareUrl(dataShareDto.getUrl());
+        digitalCardTransactionEntity.setStatusCode("AVAILABLE");
+
+        when(dataShareUtil.getDataShare(any(byte[].class), anyString(), anyString())).thenReturn(dataShareDto);
+        when(digitalCardTransactionRepository.findByRID(anyString())).thenReturn(null);
+
+        ReflectionTestUtils.invokeMethod(digitalCardService, "digitalCardStatusUpdate", requestId, data, credentialType, rid);
+
+        verify(dataShareUtil).getDataShare(eq(data), anyString(), anyString());
+        verify(digitalCardTransactionRepository).findByRID(eq(rid));
+        verify(digitalCardTransactionRepository).save(any(DigitalCardTransactionEntity.class));
+    }
+
+    @Test
+    public void testGetRid() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        Method method = DigitalCardServiceImpl.class.getDeclaredMethod("getRid", Object.class);
+        method.setAccessible(true);
+        Object id = "http://example.com/credentials/123";
+        String result = (String) method.invoke(digitalCardService, id);
+
+        assertEquals("123", result);
+    }
+
+    @Test
+    public void getPasswordTest() throws NoSuchMethodException {
+        Method getPasswordMethod = DigitalCardServiceImpl.class.getDeclaredMethod("getPassword", org.json.JSONObject.class);
+        getPasswordMethod.setAccessible(true);
+        assertThrows(Exception.class, () -> {
+            getPasswordMethod.invoke(digitalCardService, (JSONObject) null);
+        });
+    }
+
+    @Test
+    public void testGetPassword() throws Exception {
+        String digitalCardPassword="attr1|attr2|attr3";
+        String templateLang="eng";
+        String[] attributes = digitalCardPassword.split("\\|");
+
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("attr1", "value1");
+        jsonObject.put("attr2", "value2");
+        jsonObject.put("attr3", "value3");
+        ReflectionTestUtils.setField(digitalCardService, "digitalCardPassword", digitalCardPassword);
+        ReflectionTestUtils.setField(digitalCardService, "templateLang", templateLang);
+        ReflectionTestUtils.invokeMethod(digitalCardService, "getPassword", jsonObject);
+    }
+
+    @Test
+    public void getFormattedPasswordAttributeTestNew(){
+        String password="hvhjeyeyd#hvhdv@";
+        ReflectionTestUtils.invokeMethod(digitalCardService, "getFormattedPasswordAttribute", password);
+    }
+
+    @Test
+    public void testGetFormattedPasswordAttribute_LengthThree() {
+        String password = "abc";
+        String result = ReflectionTestUtils.invokeMethod(digitalCardService, "getFormattedPasswordAttribute", password);
+        assertEquals("abca", result);
+    }
+
+    @Test
+    public void testGetFormattedPasswordAttribute_LengthTwo() {
+        String password = "ab";
+        String result = ReflectionTestUtils.invokeMethod(digitalCardService, "getFormattedPasswordAttribute", password);
+        assertEquals("abab", result);
+    }
+
+    @Test
+    public void testGetFormattedPasswordAttribute_LengthOne() {
+        String password = "a";
+        String result = ReflectionTestUtils.invokeMethod(digitalCardService, "getFormattedPasswordAttribute", password);
+        assertEquals("aaaa", result);
+    }
+
+    @Test
+    public void loginErrorDetailsTest(){
+        String rid = "sampleRid";
+        String errorMsg = "sampleErrorMsg";
+        LocalDateTime currentTime = LocalDateTime.now();
+        String user = "sampleUser";
+
+        digitalCardService.loginErrorDetails(rid, errorMsg);
+    }
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/service/PDFCardServiceImplTest.java b/src/test/test/java/io/mosip/digitalcard/test/service/PDFCardServiceImplTest.java
new file mode 100644
index 0000000..4e25948
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/service/PDFCardServiceImplTest.java
@@ -0,0 +1,204 @@
+package io.mosip.digitalcard.test.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.mosip.biometrics.util.ConvertRequestDto;
+import io.mosip.digitalcard.constant.DigitalCardServiceErrorCodes;
+import io.mosip.digitalcard.dto.SignatureResponseDto;
+import io.mosip.digitalcard.exception.IdentityNotFoundException;
+import io.mosip.digitalcard.service.impl.PDFCardServiceImpl;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.digitalcard.util.CbeffToBiometricUtil;
+import io.mosip.digitalcard.util.RestClient;
+import io.mosip.digitalcard.util.TemplateGenerator;
+import io.mosip.kernel.biometrics.spi.CbeffUtil;
+import io.mosip.kernel.core.http.ResponseWrapper;
+import io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator;
+import io.mosip.kernel.core.qrcodegenerator.exception.QrcodeGenerationException;
+import io.mosip.kernel.core.qrcodegenerator.spi.QrCodeGenerator;
+import io.mosip.kernel.qrcode.generator.zxing.constant.QrVersion;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
+import org.json.simple.JSONObject;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class PDFCardServiceImplTest {
+
+    @Mock
+    private ObjectMapper objectMapper;
+
+    @InjectMocks
+    private PDFCardServiceImpl pdfCardService;
+
+    @Mock
+    private TemplateGenerator templateGenerator;
+
+    @Mock
+    private QrCodeGenerator<QrVersion> qrCodeGenerator;
+
+    @Mock
+    private PDFGenerator pdfGenerator;
+
+    @Mock
+    private RestClient restApiClient;
+
+    private static final String APPLICANT_PHOTO = "ApplicantPhoto";
+    private static final String FACE = "Face";
+    private static final String DATETIME_PATTERN ="yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
+
+    @Mock
+    CbeffUtil cbeffutil;
+
+    @Test
+    public void generateCardTest() throws Exception {
+        org.json.JSONObject decryptedCredentialJson = new org.json.JSONObject();
+        decryptedCredentialJson.put("UIN", "testUIN");
+        decryptedCredentialJson.put("biometrics", "sampleBiometricsData");
+        boolean isPhotoSet=true;
+        decryptedCredentialJson.put("isPhotoSet",isPhotoSet);
+        String credentialType = "qrcode";
+        String password = "testPassword";
+        Map<String, Object> additionalAttributes = new HashMap<>();
+        additionalAttributes.put("TEMPLATE_TYPE_CODE", "templateTypeCode");
+        Map<String, Object> attributes = new LinkedHashMap<>();
+        attributes.put("key","value");
+
+        String defaultTemplateTypeCode="RPR_UIN_CARD_TEMPLATE";
+        ReflectionTestUtils.setField(pdfCardService, "defaultTemplateTypeCode", defaultTemplateTypeCode);
+
+        String uin = decryptedCredentialJson.getString("UIN");
+
+        InputStream mockInputStream = mock(InputStream.class);
+        lenient().when(templateGenerator.getTemplate(anyString(), anyMap(), anyString())).thenReturn(mockInputStream);
+
+        try {
+            byte[] result = pdfCardService.generateCard(decryptedCredentialJson, credentialType, password, additionalAttributes);
+
+            assertNotNull(result);
+            verify(templateGenerator, times(1)).getTemplate(anyString(), anyMap(), anyString());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void setQrCodeTest() throws QrcodeGenerationException, IOException {
+
+        String qrString = "{\"biometrics\":\"sampleBiometricsData\", \"otherKey\":\"otherValue\"}";
+        Map<String, Object> attributes = new HashMap<>();
+        attributes.put("xyz","cdcs");
+        boolean isPhotoSet = true;
+
+        JSONObject qrJsonObj = new JSONObject();
+        qrJsonObj.put("biometrics", "sampleBiometricsData");
+        qrJsonObj.put("otherKey", "otherValue");
+        when(objectMapper.readValue(anyString(), eq(JSONObject.class))).thenReturn(qrJsonObj);
+        byte[] qrCodeBytes = "sampleQRCode".getBytes();
+        when(qrCodeGenerator.generateQrCode(anyString(), any())).thenReturn(qrCodeBytes);
+
+        ReflectionTestUtils.invokeMethod(pdfCardService, "setQrCode", qrString, attributes, isPhotoSet);
+    }
+
+    @Test
+    public void testSetApplicantPhoto_NullInput() throws Exception {
+        String individualBio = null;
+        Map<String, Object> attributes = new HashMap<>();
+
+        String value = individualBio;
+        List<String> subtype = new ArrayList<>();
+        CbeffToBiometricUtil util = new CbeffToBiometricUtil(cbeffutil);
+        ConvertRequestDto convertRequestDto = new ConvertRequestDto();
+        byte[] photoByte = util.getImageBytes(value, FACE, subtype);
+        convertRequestDto.setVersion("ISO19794_5_2011");
+        convertRequestDto.setInputBytes(photoByte);
+
+        Method setApplicantPhotoMethod = PDFCardServiceImpl.class.getDeclaredMethod("setApplicantPhoto",String.class, Map.class);
+        setApplicantPhotoMethod.setAccessible(true);
+        boolean isPhotoSet = (boolean) setApplicantPhotoMethod.invoke(pdfCardService, null, attributes);
+
+        Field field = PDFCardServiceImpl.class.getDeclaredField("APPLICANT_PHOTO");
+        field.setAccessible(true);
+        String applicantPhoto = (String) field.get(null);
+
+        assertFalse(isPhotoSet);
+        assertFalse(attributes.containsKey(applicantPhoto));
+    }
+
+
+    @Test
+    public void testSetTemplateAttributes_DemographicIdentityIsNull() {
+        Map<String, Object> attribute = new HashMap<>();
+        IdentityNotFoundException thrown = assertThrows(
+                IdentityNotFoundException.class,
+                () -> ReflectionTestUtils.invokeMethod(pdfCardService, "setTemplateAttributes", null, attribute)
+        );
+
+        assertEquals(DigitalCardServiceErrorCodes.IDENTITY_NOT_FOUND.getErrorCode(), thrown.getErrorCode());
+    }
+
+    @Test
+    public void generateUinCardTest() throws IOException {
+        InputStream in = new ByteArrayInputStream(new byte[]{1, 2, 3, 4});
+        String password = "samplePassword";
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        out.write(new byte[]{5, 6, 7, 8});
+
+        int lowerLeftX=73;
+        int lowerLeftY=100;
+        int upperRightX=300;
+        int upperRightY=300;
+        String reason="signing";
+
+        ReflectionTestUtils.setField(pdfCardService, "lowerLeftX", lowerLeftX);
+        ReflectionTestUtils.setField(pdfCardService, "lowerLeftY", lowerLeftY);
+        ReflectionTestUtils.setField(pdfCardService, "upperRightX", upperRightX);
+        ReflectionTestUtils.setField(pdfCardService, "upperRightY", upperRightY);
+        ReflectionTestUtils.setField(pdfCardService, "reason", reason);
+
+        ReflectionTestUtils.invokeMethod(pdfCardService, "generateUinCard", in, password);
+    }
+
+    @Test
+    public void testGenerateUinCard() throws Exception {
+        InputStream inputStream = new ByteArrayInputStream("pdf content".getBytes());
+        String password = "testPassword";
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        outputStream.write("pdf content".getBytes());
+
+        when(pdfGenerator.generate(any(InputStream.class))).thenReturn(outputStream);
+        SignatureResponseDto signatureResponseDto = new SignatureResponseDto();
+
+        ResponseWrapper<SignatureResponseDto> responseWrapper = new ResponseWrapper<>();
+        responseWrapper.setResponse(signatureResponseDto);
+
+        lenient().when(restApiClient.postApi(any(), any(), any(), any(), any(), any(), any()))
+                .thenReturn(responseWrapper);
+        lenient().when(objectMapper.writeValueAsString(any())).thenReturn("{}");
+        lenient().when(objectMapper.readValue(anyString(), eq(SignatureResponseDto.class))).thenReturn(signatureResponseDto);
+
+        Method method = PDFCardServiceImpl.class.getDeclaredMethod("generateUinCard", InputStream.class, String.class);
+        method.setAccessible(true);
+        byte[] result = (byte[]) method.invoke(pdfCardService, inputStream, password);
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/CbeffToBiometricUtilTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/CbeffToBiometricUtilTest.java
new file mode 100644
index 0000000..101b261
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/CbeffToBiometricUtilTest.java
@@ -0,0 +1,99 @@
+package io.mosip.digitalcard.test.util;
+
+import io.mosip.digitalcard.util.CbeffToBiometricUtil;
+import io.mosip.kernel.biometrics.constant.BiometricType;
+import io.mosip.kernel.biometrics.entities.BIR;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hibernate.validator.internal.util.Contracts.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
+import static org.powermock.api.mockito.PowerMockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CbeffToBiometricUtilTest {
+
+    @InjectMocks
+    CbeffToBiometricUtil cbeffToBiometricUtil;
+
+    @Test
+    public void testGetImageBytes_Success() {
+        String cbeffFileString = "validCbeff";
+        String type = "face";
+        List<String> subType = List.of("front");
+        byte[] expectedPhotoBytes = new byte[]{1, 2, 3};
+
+        try {
+            byte[] actualPhotoBytes = cbeffToBiometricUtil.getImageBytes(cbeffFileString, type, subType);
+            assertArrayEquals(expectedPhotoBytes, actualPhotoBytes);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testIsSubType_EqualLists() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
+        Method method = CbeffToBiometricUtil.class.getDeclaredMethod("isSubType", List.class, List.class);
+        ((Method) method).setAccessible(true);
+
+        List<String> list1 = Arrays.asList("A", "B", "C");
+        List<String> list2 = Arrays.asList("A", "B", "C");
+
+        boolean result = (boolean) method.invoke(cbeffToBiometricUtil, list1, list2);
+
+        assertTrue(result, "The lists should be equal");
+    }
+
+    @Test
+    public void testIsSubType_true() throws Exception {
+        List<String> subType = Arrays.asList("A", "B");
+        List<String> subTypeList = Arrays.asList("A", "B");
+
+        Method method = CbeffToBiometricUtil.class.getDeclaredMethod("isSubType", List.class, List.class);
+        method.setAccessible(true);
+        boolean result = (boolean) method.invoke(cbeffToBiometricUtil, subType, subTypeList);
+    }
+
+    @Test
+    public void testIsBiometricType_Found() {
+        String type = "fingerprint";
+        List<BiometricType> biometricTypeList = new ArrayList<>();
+        biometricTypeList.add(BiometricType.DNA);
+        biometricTypeList.add(BiometricType.IRIS);
+
+        ReflectionTestUtils.invokeMethod(cbeffToBiometricUtil,"isBiometricType",type,biometricTypeList);
+    }
+
+    @Test
+    public void testGetBIRDataFromXML_Success() throws Exception {
+        byte[] xmlBytes = "<test>sample data</test>".getBytes();
+        List<BIR> expectedBIRList = Arrays.asList(new BIR(), new BIR());
+
+        List<BIR> actualBIRList = cbeffToBiometricUtil.getBIRDataFromXML(xmlBytes);
+    }
+
+    @Test
+    public void testGetPhotoByTypeAndSubType_Found() throws Exception {
+
+        BIR bir = mock(BIR.class);
+
+        List<BIR> birList = Arrays.asList(bir);
+        String type = "face";
+        List<String> subType = Arrays.asList("subtype1");
+
+        Method method = CbeffToBiometricUtil.class.getDeclaredMethod("getPhotoByTypeAndSubType", List.class, String.class, List.class);
+        method.setAccessible(true);
+
+        byte[] actualPhoto = (byte[]) method.invoke(cbeffToBiometricUtil, birList, type, subType);
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/CredentialUtilTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/CredentialUtilTest.java
new file mode 100644
index 0000000..193bb4b
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/CredentialUtilTest.java
@@ -0,0 +1,72 @@
+package io.mosip.digitalcard.test.util;
+
+import io.mosip.digitalcard.constant.ApiName;
+import io.mosip.digitalcard.dto.CredentialRequestDto;
+import io.mosip.digitalcard.dto.CredentialResponse;
+import io.mosip.digitalcard.dto.CredentialStatusResponse;
+import io.mosip.digitalcard.exception.ApisResourceAccessException;
+import io.mosip.digitalcard.exception.DigitalCardServiceException;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.digitalcard.util.CredentialUtil;
+import io.mosip.digitalcard.util.RestClient;
+import io.mosip.kernel.core.http.RequestWrapper;
+import io.mosip.kernel.core.http.ResponseWrapper;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Mockito.lenient;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class CredentialUtilTest {
+
+    @InjectMocks
+    CredentialUtil credentialUtil;
+
+    @Mock
+    private RestClient restClient;
+
+    String requestId="sampleRequestId";
+
+    @Test
+    public void reqCredentialTest() throws ApisResourceAccessException {
+        RequestWrapper<CredentialRequestDto> requestDto = new RequestWrapper<>();
+        CredentialRequestDto credentialRequestDto = new CredentialRequestDto();
+        requestDto.setRequest(credentialRequestDto);
+        requestDto.setRequesttime(LocalDateTime.now());
+
+        ResponseWrapper<CredentialResponse> responseDto = new ResponseWrapper<>();
+        CredentialResponse expectedResponse = new CredentialResponse();
+        responseDto.setResponse(expectedResponse);
+
+        lenient().when(restClient.postApi(any(ApiName.class), any(), any(), any(), any(), any(RequestWrapper.class), any(Class.class)))
+                .thenReturn(responseDto);
+
+    }
+    @Test
+    public void getStatusTest() {
+        List<String> pathSegments = new ArrayList<>();
+        pathSegments.add(requestId);
+
+        ResponseWrapper<CredentialStatusResponse> responseWrapper = new ResponseWrapper<>();
+        CredentialStatusResponse expectedResponse = new CredentialStatusResponse();
+        responseWrapper.setResponse(expectedResponse);
+
+        assertThrows(DigitalCardServiceException.class, () -> {
+            credentialUtil.getStatus(requestId);
+        });
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/DataShareUtilTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/DataShareUtilTest.java
new file mode 100644
index 0000000..45c1742
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/DataShareUtilTest.java
@@ -0,0 +1,36 @@
+package io.mosip.digitalcard.test.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.mosip.digitalcard.dto.DataShareDto;
+import io.mosip.digitalcard.dto.DataShareResponseDto;
+import io.mosip.digitalcard.util.DataShareUtil;
+import io.mosip.digitalcard.util.DigitalCardRepoLogger;
+import io.mosip.digitalcard.util.RestClient;
+import io.mosip.kernel.core.logger.spi.Logger;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.core.env.Environment;
+
+import static org.powermock.api.mockito.PowerMockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class DataShareUtilTest {
+
+    @InjectMocks
+    DataShareUtil dataShareUtil;
+
+    @Test
+    public void testGetDataShareSuccess() throws Exception {
+        byte[] data = {1, 2, 3};
+        String policyId = "policyId";
+        String partnerId = "partnerId";
+        DataShareResponseDto mockResponseDto = mock(DataShareResponseDto.class);
+        DataShareDto mockDataShareDto = mock(DataShareDto.class);
+
+        DataShareDto result = dataShareUtil.getDataShare(data, "sacdc", "acacad");
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/EncryptionUtilTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/EncryptionUtilTest.java
new file mode 100644
index 0000000..2d26436
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/EncryptionUtilTest.java
@@ -0,0 +1,52 @@
+package io.mosip.digitalcard.test.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.mosip.digitalcard.util.EncryptionUtil;
+import io.mosip.digitalcard.util.RestClient;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.core.env.Environment;
+import io.mosip.digitalcard.dto.CryptomanagerResponseDto;
+
+import static org.powermock.api.mockito.PowerMockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class EncryptionUtilTest {
+
+    @InjectMocks
+    EncryptionUtil encryptionUtil;
+
+    @Test
+    public void testDecryptDataTest() {
+        String dataToBedecrypted = "encryptedData";
+        String responseData = "decryptedData";
+        CryptomanagerResponseDto responseDto = new CryptomanagerResponseDto();
+
+        try {
+            String result = encryptionUtil.decryptData(dataToBedecrypted);
+        } catch (Exception e) {
+            e.printStackTrace();
+
+        }
+    }
+
+    @Test
+    public void testDecryptData_Success() {
+        String dataToBeDecrypted = "encrypted_data";
+        String expectedDecryptedData = "decrypted_data";
+
+        Environment mockEnv = mock(Environment.class);
+        RestClient mockRestClient = mock(RestClient.class);
+        ObjectMapper mockMapper = mock(ObjectMapper.class);
+
+        try{
+            String decryptedData = encryptionUtil.decryptData(dataToBeDecrypted);
+        }
+        catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/RestClientTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/RestClientTest.java
new file mode 100644
index 0000000..8865081
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/RestClientTest.java
@@ -0,0 +1,122 @@
+package io.mosip.digitalcard.test.util;
+
+import io.mosip.digitalcard.constant.ApiName;
+import io.mosip.digitalcard.exception.ApisResourceAccessException;
+import io.mosip.digitalcard.util.RestClient;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.core.env.Environment;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.http.MediaType;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RestClientTest {
+
+    @InjectMocks
+    RestClient restClient;
+
+    @Mock
+    Environment environment;
+
+    @Mock
+    private RestTemplate restTemplate;
+
+    @Test
+    public void postApiTest() throws ApisResourceAccessException {
+        ApiName apiName = ApiName.CREDENTIAL_STATUS_URL;
+        List<String> pathSegments = Arrays.asList("segment1", "segment2");
+        String queryParamName = "param1,param2";
+        String queryParamValue = "value1,value2";
+        MediaType mediaType = MediaType.APPLICATION_JSON;
+        Object requestType = new Object();
+        Class<String> responseClass = String.class;
+
+        when(environment.getProperty(apiName.name())).thenReturn("http://localhost:8080");
+        String expectedResponse = "response";
+        when(restTemplate.postForObject(anyString(), any(), eq(responseClass))).thenReturn(expectedResponse);
+        RestClient client = Mockito.spy(restClient);
+
+        String result = restClient.postApi(apiName, pathSegments, queryParamName, queryParamValue, mediaType, requestType, responseClass);
+
+        assertNotNull(result);
+        assertEquals(expectedResponse, result);
+
+        UriComponentsBuilder builder = UriComponentsBuilder.fromUriString("http://localhost:8080")
+                .pathSegment("segment1")
+                .pathSegment("segment2")
+                .queryParam("param1", "value1")
+                .queryParam("param2", "value2");
+        String expectedUri = builder.toUriString();
+        verify(restTemplate).postForObject(eq(expectedUri), any(), eq(responseClass));
+    }
+
+    @Test
+    public void testPostApi_noHostIpPort() throws ApisResourceAccessException {
+        ApiName apiName = ApiName.CREDENTIAL_STATUS_URL;
+        List<String> pathSegments = Arrays.asList("segment1", "segment2");
+        String queryParamName = "param1,param2";
+        String queryParamValue = "value1,value2";
+        MediaType mediaType = MediaType.APPLICATION_JSON;
+        Object requestType = new Object();
+        Class<String> responseClass = String.class;
+
+        String result = restClient.postApi(apiName, pathSegments, queryParamName, queryParamValue, mediaType, requestType, responseClass);
+
+        assertNull(result);
+
+        verify(restTemplate, never()).postForObject(anyString(), any(), eq(responseClass));
+    }
+
+    @Test
+    public void testGetForObject_Success() throws Exception {
+        String url = "http://example.com/api/resource";
+        String expectedResponse = "Expected response";
+        when(restTemplate.getForObject(url, String.class)).thenReturn(expectedResponse);
+
+        String actualResponse = restClient.getForObject(url, String.class);
+
+        assertEquals(expectedResponse, actualResponse);
+        verify(restTemplate, times(1)).getForObject(url, String.class);
+    }
+    @Test
+    public void testGetForObject_Exception() {
+        String url = "http://example.com/api/resource";
+        when(restTemplate.getForObject(url, String.class)).thenThrow(new RuntimeException("Test exception"));
+
+        Exception exception = assertThrows(Exception.class, () -> {
+            restClient.getForObject(url, String.class);
+        });
+
+        assertEquals("java.lang.RuntimeException: Test exception", exception.getMessage());
+        verify(restTemplate, times(1)).getForObject(url, String.class);
+    }
+
+    @Test
+    public void testGetApi_ApiHostIpPortNull() throws Exception {
+        ApiName apiName=ApiName.CREDENTIAL_STATUS_URL;
+        List<String> pathSegments = Arrays.asList("segment1", "segment2");
+        String queryParamName = "param1,param2";
+        String queryParamValue = "value1,value2";
+        Class<?> responseType=String.class;
+
+        when(environment.getProperty(apiName.name())).thenReturn(null);
+
+        String result = restClient.getApi(apiName, pathSegments, queryParamName, queryParamValue, responseType);
+
+        assertNull(result);
+        verify(environment, times(1)).getProperty(apiName.name());
+        verifyNoInteractions(restTemplate);  // Ensure restTemplate is not called
+    }
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/TemplateGeneratorTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/TemplateGeneratorTest.java
new file mode 100644
index 0000000..5c3cc59
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/TemplateGeneratorTest.java
@@ -0,0 +1,63 @@
+package io.mosip.digitalcard.test.util;
+
+import io.mosip.digitalcard.util.DigitalCardRepoLogger;
+import io.mosip.digitalcard.util.TemplateGenerator;
+import io.mosip.kernel.core.logger.spi.Logger;
+import io.mosip.kernel.core.templatemanager.spi.TemplateManager;
+import io.mosip.kernel.templatemanager.velocity.impl.TemplateManagerImpl;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.core.env.Environment;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TemplateGeneratorTest {
+
+    @InjectMocks
+    TemplateGenerator templateGenerator;
+
+    @Mock
+    Environment environment;
+
+    private static Logger printLogger = DigitalCardRepoLogger.getLogger(TemplateGenerator.class);
+    private String resourceLoader = "classpath";
+    private String templatePath = ".";
+    private boolean cache = Boolean.TRUE;
+    private String defaultEncoding = StandardCharsets.UTF_8.name();
+
+    @Test
+    public void testGetTemplate_Success2() throws Exception {
+        String cardTemplate= "templateCard";
+        Map<String, Object> attributes = new HashMap<>();
+
+        String encodedTemplate = Base64.getEncoder().encodeToString("template-content".getBytes());
+        InputStream expectedStream = new ByteArrayInputStream("merged-content".getBytes());
+
+        when(environment.getProperty(cardTemplate)).thenReturn(encodedTemplate);
+
+        InputStream actualStream = templateGenerator.getTemplate(cardTemplate, attributes, "eng");
+    }
+
+    @Test
+    public void testGetTemplateManager_Success() {
+        TemplateManager templateManager = templateGenerator.getTemplateManager();
+
+        assertNotNull(templateManager);
+        assertTrue(templateManager instanceof TemplateManagerImpl);
+
+    }
+
+}
diff --git a/src/test/test/java/io/mosip/digitalcard/test/util/UtilityTest.java b/src/test/test/java/io/mosip/digitalcard/test/util/UtilityTest.java
new file mode 100644
index 0000000..38d0202
--- /dev/null
+++ b/src/test/test/java/io/mosip/digitalcard/test/util/UtilityTest.java
@@ -0,0 +1,114 @@
+package io.mosip.digitalcard.test.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.mosip.digitalcard.test.TestBootApplication;
+import io.mosip.digitalcard.util.RestClient;
+import io.mosip.digitalcard.util.Utility;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+
+import static org.mockito.Mockito.*;
+import static org.powermock.api.mockito.PowerMockito.when;
+
+@SpringBootTest(classes = TestBootApplication.class)
+@RunWith(MockitoJUnitRunner.class)
+public class UtilityTest {
+
+    @InjectMocks
+    Utility utility;
+
+    @Mock
+    RestClient restClient;
+
+    @Mock
+    ObjectMapper objectMapper;
+
+    private static final Logger logger = LoggerFactory.getLogger(Utility.class);
+    @Value("${mosip.kernel.config.server.file.storage.uri}")
+    private String configServerFileStorageURL;
+    private String identityJson = "jsbcdbic";
+    private String demographicIdentity = "jdbicbic";
+    private String expectedJsonResponse = "{loadRegProcessorIdentityJson completed successfully}";
+
+    @Test
+    public void loadRegProcessorIdentityJsonTest() {
+        ReflectionTestUtils.invokeMethod(utility, "loadRegProcessorIdentityJson");
+    }
+
+    @Test
+    public void testGetIdentityMappingJson_WhenBlank_ShouldFetchFromService() throws Exception {
+        when(restClient.getForObject(configServerFileStorageURL + identityJson, String.class))
+                .thenReturn(expectedJsonResponse);
+        String actualJsonResponse = utility.getIdentityMappingJson(configServerFileStorageURL, identityJson);
+
+        verify(restClient, times(1))
+                .getForObject(configServerFileStorageURL + identityJson, String.class);
+    }
+
+    @Test
+    public void testGetMappingJsonObject_WhenBlank_ShouldFetchAndParseJson() throws Exception {
+        JSONObject actualJsonObject = utility.getMappingJsonObject();
+    }
+
+    @Test
+    public void testGetJSONObject_WhenKeyIsPresentAndValueIsLinkedHashMap_ShouldReturnJsonObject() {
+        LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
+        linkedHashMap.put("key1", "value1");
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("identity", linkedHashMap);
+
+        JSONObject result = utility.getJSONObject(jsonObject, "identity");
+    }
+
+    @Test
+    public void getJSONValueTest() {
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("key1", "value1");
+
+        String result = utility.getJSONValue(jsonObject, "key1");
+    }
+
+    @Test
+    public void writeValueAsStringTest() throws IOException {
+        Object obj = new Object();
+        String expectedJson = "{\"key\":\"value\"}";
+
+        when(objectMapper.writeValueAsString(obj)).thenReturn(expectedJson);
+
+        String actualJson = utility.writeValueAsString(obj);
+    }
+
+    @Test
+    public void getJSONArrayTest() {
+        ArrayList<String> list = new ArrayList<>(Arrays.asList("value1", "value2", "value3"));
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("key1", list);
+
+        JSONArray jsonArray = utility.getJSONArray(jsonObject, "key1");
+    }
+
+    @Test
+    public void testGetJSONArray_WhenKeyExistsAndValueIsNull_ShouldReturnNull() {
+        JSONObject jsonObject = new JSONObject();
+        jsonObject.put("key3", null);
+
+        JSONArray jsonArray = utility.getJSONArray(jsonObject, "key3");
+    }
+
+}