diff --git a/registration-processor/core-processor/registration-processor-bio-dedupe-stage/src/test/java/io/mosip/registration/processor/biodedupe/stage/BioDedupeProcessorTest.java b/registration-processor/core-processor/registration-processor-bio-dedupe-stage/src/test/java/io/mosip/registration/processor/biodedupe/stage/BioDedupeProcessorTest.java
index 314c4346072..0562654745a 100644
--- a/registration-processor/core-processor/registration-processor-bio-dedupe-stage/src/test/java/io/mosip/registration/processor/biodedupe/stage/BioDedupeProcessorTest.java
+++ b/registration-processor/core-processor/registration-processor-bio-dedupe-stage/src/test/java/io/mosip/registration/processor/biodedupe/stage/BioDedupeProcessorTest.java
@@ -19,6 +19,7 @@
 import io.mosip.registration.processor.biodedupe.stage.exception.CbeffNotFoundException;
 import io.mosip.registration.processor.core.code.*;
 import io.mosip.registration.processor.core.constant.ProviderStageName;
+import io.mosip.registration.processor.core.constant.RegistrationType;
 import io.mosip.registration.processor.core.exception.*;
 import io.mosip.registration.processor.core.packet.dto.abis.ProcessedMatchedResult;
 import io.mosip.registration.processor.packet.storage.utils.PriorityBasedPacketManagerService;
@@ -947,4 +948,32 @@ public void testProcess_ThrowsBiometricClassificationException() throws PacketMa
 		assertEquals(MessageBusAddress.VERIFICATION_BUS_IN, result.getMessageBusAddress());
 	}
 
+	@Test
+	public void testProcessWhenExceptionOccursShouldSetValidStatusFalseAndInternalErrorTrue() {
+
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("10031100110005020190313110030");
+		when(abisHandlerUtil.getPacketStatus(any()))
+				.thenThrow(new RuntimeException("test exception"));
+		MessageDTO result = bioDedupeProcessor.process(messageDTO, stageName);
+
+		assertFalse(result.getIsValid());
+		assertTrue(result.getInternalError());
+	}
+
+	@Test
+	public void testNewPacketPreAbisIdentificationWhenInfantDedupeDisabledSuccessStatus() throws ApisResourceAccessException, PacketManagerException, IOException, JsonProcessingException {
+
+		ReflectionTestUtils.setField(bioDedupeProcessor, "infantDedupe", "N");
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setReg_type(RegistrationType.NEW.name());
+		Mockito.when(bioDedupeService.getFileByRegId(anyString(),anyString())).thenReturn(null);
+		Mockito.when(utility.getApplicantAge(any(),any(),any())).thenReturn(3);
+		MessageDTO messageDto = bioDedupeProcessor.process(messageDTO, stageName);
+		assertTrue(messageDto.getIsValid());
+		assertEquals(MessageBusAddress.BIO_DEDUPE_BUS_IN, messageDTO.getMessageBusAddress());
+		assertEquals(RegistrationStatusCode.PROCESSING.name(), registrationStatusDto.getStatusCode());
+		assertEquals(RegistrationTransactionStatusCode.SUCCESS.name(), registrationStatusDto.getLatestTransactionStatusCode());
+	}
+
 }
\ No newline at end of file
diff --git a/registration-processor/core-processor/registration-processor-manual-adjudication-stage/src/test/java/io/mosip/registration/processor/verification/service/ManualAdjudicationServiceTest.java b/registration-processor/core-processor/registration-processor-manual-adjudication-stage/src/test/java/io/mosip/registration/processor/verification/service/ManualAdjudicationServiceTest.java
index 34663c56535..7a564c6f2be 100644
--- a/registration-processor/core-processor/registration-processor-manual-adjudication-stage/src/test/java/io/mosip/registration/processor/verification/service/ManualAdjudicationServiceTest.java
+++ b/registration-processor/core-processor/registration-processor-manual-adjudication-stage/src/test/java/io/mosip/registration/processor/verification/service/ManualAdjudicationServiceTest.java
@@ -3,6 +3,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.mockito.ArgumentMatchers.*;
 
 import java.io.File;
@@ -22,6 +24,7 @@
 import io.mosip.registration.processor.adjudication.request.dto.Filter;
 import io.mosip.registration.processor.adjudication.request.dto.ShareableAttributes;
 import io.mosip.registration.processor.adjudication.request.dto.Source;
+import io.mosip.registration.processor.core.code.RegistrationExceptionTypeCode;
 import io.mosip.registration.processor.core.exception.PacketManagerNonRecoverableException;
 import org.apache.commons.io.IOUtils;
 import org.assertj.core.groups.Tuple;
@@ -31,6 +34,7 @@
 import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
@@ -812,4 +816,93 @@ public void PacketManagerNonRecoverableExceptionTest() throws Exception {
 		assertFalse(messageDTO.getIsValid());
 		assertTrue(messageDTO.getInternalError());
 	}
+
+	@Test
+	public void testProcessShouldInvalidateMessageWhenDataShareUrlPresent() throws Exception {
+
+		ShareableAttributes shareableAttributes1 = new ShareableAttributes();
+		shareableAttributes1.setAttributeName("biometrics");
+		shareableAttributes1.setEncrypted(true);
+
+		List<Source> sourceList = new ArrayList<>();
+		Source source1 = new Source();
+		source1.setAttribute("biometrics");
+		List<Filter> filterlist = new ArrayList<>();
+		Filter filter11 = new Filter();
+		filter11.setLanguage("lang");
+		filter11.setType("type");
+		filterlist.add(filter11);
+		source1.setFilter(filterlist);
+		sourceList.add(source1);
+
+		shareableAttributes1.setSource(sourceList);
+		shareableAttributes1.setFormat("");
+		shareableAttributes1.setGroup("");
+
+		MessageDTO object = new MessageDTO();
+		object.setReg_type("NEW");
+		object.setRid("92379526572940");
+		object.setIteration(1);
+		object.setWorkflowInstanceId("26fa3eff-f3b9-48f7-b365-d7f7c2e56e00");
+		setDataShareDetails();
+
+		Map<String, String> identity = new HashMap<String, String>();
+		identity.put("fullName", "Satish");
+		Mockito.when(packetManagerService.getFields(anyString(), any(), anyString(), any())).thenReturn(identity);
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn("");
+		Mockito.when(mapper.readValue(anyString(),any(Class.class))).thenReturn(shareableAttributes1).thenReturn(shareableAttributes1).thenReturn(shareableAttributes1);
+
+		MessageDTO messageDTO = manualAdjudicationService.process(object,queue);
+
+		assertFalse(messageDTO.getIsValid());
+		assertFalse(messageDTO.getInternalError());
+	}
+
+	@Test
+	public void updatePacketStatusSuccessFlowWhenStatusRejected() {
+
+		ManualAdjudicationResponseDTO adjudicationResponseDTO = new ManualAdjudicationResponseDTO();
+		adjudicationResponseDTO.setReturnValue(4);
+		adjudicationResponseDTO.setResponsetime(DateUtils.getCurrentDateTimeString());
+		adjudicationResponseDTO.setId("mosip.manual.adjudication.adjudicate");
+		adjudicationResponseDTO.setRequestId("4d4f27d3-ec73-41c4-a384-bf87fce4969e");
+		CandidateList candidateList = new CandidateList();
+		candidateList.setCount(0);
+		adjudicationResponseDTO.setCandidateList(candidateList);
+
+		Mockito.when(basePacketRepository.getAllAssignedRecord(anyString(), anyString())).thenReturn(entities);
+		Mockito.when(registrationStatusService.getRegistrationStatus(any(), any(), any(), any())).thenReturn(registrationStatusDto);
+		Mockito.when(basePacketRepository.getAssignedApplicantDetails(anyString(), anyString())).thenReturn(null);
+		Mockito.when(basePacketRepository.update(any(ManualVerificationEntity.class))).thenReturn(manualVerificationEntity);
+		Mockito.when(basePacketRepository.getRegistrationIdbyRequestId(anyString())).thenReturn(Lists.newArrayList(manualVerificationEntity));
+
+		manualVerificationDTO.setStatusCode(ManualVerificationStatus.REJECTED.name());
+
+		ArgumentCaptor<MessageDTO> messageCaptor = ArgumentCaptor.forClass(MessageDTO.class);
+
+		Mockito.doNothing().when(manualAdjudicationStage).sendMessage(messageCaptor.capture());
+		boolean result = manualAdjudicationService.updatePacketStatus(adjudicationResponseDTO, stageName, queue);
+		assertTrue(result);
+		MessageDTO capturedMessage = messageCaptor.getValue();
+		assertNotNull(capturedMessage);
+		assertEquals(Boolean.FALSE, capturedMessage.getInternalError());
+		assertEquals(Boolean.FALSE, capturedMessage.getIsValid());
+	}
+
+	@Test
+	public void testProcessShouldHandleInvalidRidException() {
+
+		MessageDTO object = new MessageDTO();
+		object.setRid("");
+		object.setReg_type("NEW");
+		object.setIteration(1);
+		object.setWorkflowInstanceId("wf-123");
+
+		Mockito.when(registrationExceptionMapperUtil.getStatusCode(RegistrationExceptionTypeCode.MANUAL_VERIFICATION_FAILED))
+				.thenReturn("FAILED_CODE");
+
+		MessageDTO response = manualAdjudicationService.process(object, queue);
+		assertTrue(response.getInternalError());
+		assertFalse(response.getIsValid());
+	}
 }
diff --git a/registration-processor/core-processor/registration-processor-uin-generator-stage/src/test/java/io/mosip/registration/processor/stages/uigenerator/UinGeneratorStageTest.java b/registration-processor/core-processor/registration-processor-uin-generator-stage/src/test/java/io/mosip/registration/processor/stages/uigenerator/UinGeneratorStageTest.java
index c9cf704b32e..801338d21cf 100644
--- a/registration-processor/core-processor/registration-processor-uin-generator-stage/src/test/java/io/mosip/registration/processor/stages/uigenerator/UinGeneratorStageTest.java
+++ b/registration-processor/core-processor/registration-processor-uin-generator-stage/src/test/java/io/mosip/registration/processor/stages/uigenerator/UinGeneratorStageTest.java
@@ -242,6 +242,7 @@ public Integer getPort() {
 
 	/** The Constant CONFIG_SERVER_URL. */
 	private static final String CONFIG_SERVER_URL = "url";
+	private static final String IDREPO_STATUS = "DRAFTED";
 
 	private String identityMappingjsonString;
 
@@ -2775,4 +2776,206 @@ public void testProcess_WithLostPacket_ShouldReturnNull() throws Exception {
 		assertNull(demographicIdentity.get("packetCreatedOn"));
 	}
 
+	@Test
+	public void testProcessUinGenerationReprocessShouldSetReprocessStatus() throws IOException, PacketManagerException, ApisResourceAccessException, JsonProcessingException,
+			IdrepoDraftReprocessableException, IdrepoDraftException {
+		List<ErrorDTO> errors = new ArrayList<>();
+		ErrorDTO errorDTO = new ErrorDTO();
+		errorDTO.setErrorCode("IDR-IDC-004");
+		errorDTO.setMessage("Unknown error occurred");
+		errors.add(errorDTO);
+
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("10031100110005020190313110030");
+		messageDTO.setReg_type(RegistrationType.NEW.name());
+		IdResponseDTO idResponseDTO = new IdResponseDTO();
+		idResponseDTO.setErrors(errors);
+
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.IDENTITY)).thenReturn(identityObj);
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.DOCUMENT)).thenReturn(documentObj);
+		Mockito.when(registrationStatusMapperUtil
+				.getStatusCode(RegistrationExceptionTypeCode.PACKET_UIN_GENERATION_REPROCESS)).thenReturn(RegistrationTransactionStatusCode.REPROCESS.toString());
+
+		when(packetManagerService.getFields(any(), any(), any(), any())).thenReturn(new HashMap<>());
+		when(packetManagerService.getFieldByMappingJsonKey(anyString(), anyString(), any(), any())).thenReturn("0.1");
+
+		when(idrepoDraftService.idrepoUpdateDraft(anyString(), any(), any())).thenReturn(idResponseDTO);
+
+		MessageDTO result = uinGeneratorStage.process(messageDTO);
+		assertTrue(result.getInternalError());
+		assertTrue(result.getIsValid());
+	}
+
+	@Test
+	public void testProcessUinGenerationFailedShouldSetFailedStatus() throws IOException, PacketManagerException, ApisResourceAccessException, JsonProcessingException,
+			IdrepoDraftReprocessableException, IdrepoDraftException {
+
+		List<ErrorDTO> errors = new ArrayList<>();
+		ErrorDTO errorDTO = new ErrorDTO();
+		errorDTO.setErrorCode("IDR-IDC-005");
+		errors.add(errorDTO);
+
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("10031100110005020190313110030");
+		messageDTO.setReg_type(RegistrationType.NEW.name());
+		IdResponseDTO idResponseDTO = new IdResponseDTO();
+		idResponseDTO.setErrors(errors);
+
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.IDENTITY)).thenReturn(identityObj);
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.DOCUMENT)).thenReturn(documentObj);
+		Mockito.when(registrationStatusMapperUtil
+				.getStatusCode(RegistrationExceptionTypeCode.PACKET_UIN_GENERATION_FAILED)).thenReturn(RegistrationTransactionStatusCode.FAILED.toString());
+
+		when(packetManagerService.getFields(any(), any(), any(), any())).thenReturn(new HashMap<>());
+		when(packetManagerService.getFieldByMappingJsonKey(anyString(), anyString(), any(), any())).thenReturn("0.1");
+
+		when(idrepoDraftService.idrepoUpdateDraft(anyString(), any(), any())).thenReturn(idResponseDTO);
+
+		MessageDTO result = uinGeneratorStage.process(messageDTO);
+		assertTrue(result.getInternalError());
+		assertFalse(result.getIsValid());
+	}
+
+	@Test
+	public void testLostAndUpdateUinWhenIdRepoDraftReturnsNullShouldSetValidStatusFalse() throws Exception {
+		Map<String, String> fieldMap = new HashMap<>();
+		fieldMap.put("UIN", "123456");
+		fieldMap.put("name", "mono");
+		fieldMap.put("email", "mono@mono.com");
+
+		List<String> defaultFields = new ArrayList<>();
+		defaultFields.add("name");
+		defaultFields.add("dob");
+		defaultFields.add("gender");
+		defaultFields.add("UIN");
+		when(idRepoService.getUinByRid(anyString(), anyString())).thenReturn("9403107397");
+
+		when(utility.getUIn(any(),any(),any(ProviderStageName.class))).thenReturn("123456");
+		when(packetManagerService.getFieldByMappingJsonKey(anyString(),anyString(),any(),any())).thenReturn("0.1");
+		when(packetManagerService.getFields(anyString(),anyList(),anyString(),any())).thenReturn(fieldMap);
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("27847657360002520181210094052");
+		messageDTO.setReg_type(RegistrationType.LOST.name());
+		String str = "{\"id\":\"mosip.id.read\",\"version\":\"1.0\",\"responsetime\":\"2019-04-05\",\"metadata\":null,\"response\":{\"uin\":\"2812936908\"},\"errors\":[{\"errorCode\":null,\"errorMessage\":null}]}";
+		String response = "{\"timestamp\":1553771083721,\"status\":404,\"errors\":[{\"errorCode\":\"KER-UIG-004\",\"errorMessage\":\"Given UIN is not in ISSUED status\"}]}";
+
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.IDENTITY)).thenReturn(identityObj);
+		when(registrationProcessorRestClientService.putApi(any(), any(), any(), any(), any(), any(), any()))
+				.thenReturn(response);
+
+		when(packetManagerService.getField(any(), any(), any(),any())).thenReturn("989879234");
+
+		when(packetManagerService.getFieldByMappingJsonKey(any(), any(), any(), any())).thenReturn("1.0");
+		when(regLostUinDetEntity.getLostUinMatchedRegIdByWorkflowId(any())).thenReturn("27847657360002520181210094052");
+		MessageDTO result = uinGeneratorStage.process(messageDTO);
+		assertFalse(result.getInternalError());
+		assertFalse(result.getIsValid());
+	}
+
+	@Test
+	public void testReactivateUinWhenStatusActivated() throws Exception {
+
+		Map<String, String> fieldMap = new HashMap<>();
+		fieldMap.put("UIN", "123456");
+		fieldMap.put("name", "mono");
+		fieldMap.put("email", "mono@mono.com");
+
+		List<String> defaultFields = new ArrayList<>();
+		defaultFields.add("name");
+		defaultFields.add("dob");
+		defaultFields.add("gender");
+		defaultFields.add("UIN");
+
+		when(utility.getUIn(any(),any(),any(ProviderStageName.class))).thenReturn("123456");
+		when(packetManagerService.getFieldByMappingJsonKey(anyString(),anyString(),any(),any())).thenReturn("0.1");
+		when(packetManagerService.getFields(any(), any(), any(), any())).thenReturn(fieldMap);
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("27847657360002520181210094052");
+		messageDTO.setReg_type(RegistrationType.valueOf("ACTIVATED").name());
+
+		IdResponseDTO idResponseDTO = new IdResponseDTO();
+		ResponseDTO responseDTO = new ResponseDTO();
+		idResponseDTO.setErrors(null);
+		idResponseDTO.setId("mosip.id.update");
+		responseDTO.setStatus(io.mosip.registration.processor.status.code.RegistrationType.ACTIVATED.toString());
+		idResponseDTO.setResponse(responseDTO);
+		idResponseDTO.setResponsetime("2019-01-17T06:29:01.940Z");
+		idResponseDTO.setVersion("1.0");
+
+		IdResponseDTO idResponseDTO1 = new IdResponseDTO();
+		ResponseDTO responseDTO1 = new ResponseDTO();
+		idResponseDTO1.setErrors(null);
+		idResponseDTO1.setId("mosip.id.update");
+		responseDTO1.setStatus("DEACTIVATED");
+		idResponseDTO1.setResponse(responseDTO1);
+		idResponseDTO1.setResponsetime("2019-01-17T06:29:01.940Z");
+		idResponseDTO1.setVersion("1.0");
+
+		when(registrationProcessorRestClientService.getApi(any(), any(), anyString(), any(), any()))
+				.thenReturn(idResponseDTO1);
+
+		when(idrepoDraftService.idrepoUpdateDraft(anyString(), any(), any())).thenReturn(idResponseDTO);
+		when(registrationProcessorRestClientService.patchApi(any(), any(), any(), any(), any(), any()))
+				.thenReturn(idResponseDTO1);
+		MessageDTO result = uinGeneratorStage.process(messageDTO);
+		assertTrue(result.getIsValid());
+		assertFalse(result.getInternalError());
+	}
+
+	@Test
+	public void testUinUpdateWhenIdRepoStatusDraftedShouldReturnTrue() throws ApisResourceAccessException, IOException, JsonProcessingException,
+			PacketManagerException, JSONException, IdrepoDraftException, IdrepoDraftReprocessableException {
+		Map<String, String> fieldMap = new HashMap<>();
+		fieldMap.put("UIN", "123456");
+		fieldMap.put("name", "mono");
+		fieldMap.put("email", "mono@mono.com");
+
+		List<String> defaultFields = new ArrayList<>();
+		defaultFields.add("name");
+		defaultFields.add("dob");
+		defaultFields.add("gender");
+		defaultFields.add("UIN");
+
+		when(utility.getUIn(any(),any(),any(ProviderStageName.class))).thenReturn("123456");
+		when(packetManagerService.getFields(any(), any(), any(), any())).thenReturn(fieldMap);
+
+		when(packetManagerService.getFieldByMappingJsonKey(anyString(),anyString(),any(),any())).thenReturn("0.1");
+		when(packetManagerService.getFields(anyString(),anyList(),anyString(),any())).thenReturn(fieldMap);
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+
+		when(idSchemaUtil.getDefaultFields(anyDouble())).thenReturn(defaultFields);
+		MessageDTO messageDTO = new MessageDTO();
+		messageDTO.setRid("10031100110005020190313110030");
+		messageDTO.setReg_type(RegistrationType.valueOf("UPDATE").name());
+		IdResponseDTO responsedto = new IdResponseDTO();
+
+		IdResponseDTO idResponseDTO = new IdResponseDTO();
+		ResponseDTO responseDTO = new ResponseDTO();
+		idResponseDTO.setErrors(null);
+		idResponseDTO.setId("mosip.id.update");
+		responseDTO.setStatus(IDREPO_STATUS);
+		idResponseDTO.setResponse(responseDTO);
+		idResponseDTO.setResponsetime("2019-03-12T06:49:30.779Z");
+		idResponseDTO.setVersion("1.0");
+
+		when(idrepoDraftService.idrepoUpdateDraft(anyString(), any(), any())).thenReturn(idResponseDTO);
+		when(registrationProcessorRestClientService.getApi(any(), any(), anyString(), any(), any()))
+				.thenReturn(responsedto);
+		when(registrationProcessorRestClientService.patchApi(any(), any(), any(), any(), any(), any()))
+				.thenReturn(idResponseDTO);
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.IDENTITY)).thenReturn(identityObj);
+		when(utilities.getRegistrationProcessorMappingJson(MappingJsonConstants.DOCUMENT)).thenReturn(documentObj);
+
+		MessageDTO result = uinGeneratorStage.process(messageDTO);
+		assertTrue(result.getIsValid());
+		assertFalse(result.getInternalError());
+	}
+
 }
\ No newline at end of file
diff --git a/registration-processor/core-processor/registration-processor-verification-stage/src/test/java/io/mosip/registration/processor/verification/service/VerificationServiceTest.java b/registration-processor/core-processor/registration-processor-verification-stage/src/test/java/io/mosip/registration/processor/verification/service/VerificationServiceTest.java
index 51fb562a3e9..b362e5712a7 100644
--- a/registration-processor/core-processor/registration-processor-verification-stage/src/test/java/io/mosip/registration/processor/verification/service/VerificationServiceTest.java
+++ b/registration-processor/core-processor/registration-processor-verification-stage/src/test/java/io/mosip/registration/processor/verification/service/VerificationServiceTest.java
@@ -2,6 +2,8 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
@@ -30,6 +32,7 @@
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.Spy;
+import org.mockito.ArgumentCaptor;
 import org.powermock.core.classloader.annotations.PowerMockIgnore;
 import org.powermock.modules.junit4.PowerMockRunner;
 import org.slf4j.LoggerFactory;
@@ -535,4 +538,44 @@ public void PacketManagerNonRecoverableExceptionTest() throws ApisResourceAccess
 		assertTrue(response.getInternalError());
 	}
 
+	@Test
+	public void testSuccessFlowWhenManualVerificationRejectedShouldSetRejectedStatus() throws com.fasterxml.jackson.core.JsonProcessingException {
+
+		Mockito.when(basePacketRepository.getAssignedVerificationRecord(anyString(), anyString())).thenReturn(entities);
+		String response = objectMapper.writeValueAsString(resp);
+		ActiveMQBytesMessage amq = new ActiveMQBytesMessage();
+		ByteSequence byteSeq = new ByteSequence();
+		byteSeq.setData(response.getBytes());
+		amq.setContent(byteSeq);
+		resp.setReturnValue(4);
+		ArgumentCaptor<MessageDTO> messageCaptor = ArgumentCaptor.forClass(MessageDTO.class);
+		Mockito.doNothing().when(manualAdjudicationStage).sendMessage(messageCaptor.capture());
+		boolean result = verificationService.updatePacketStatus(resp, stageName, queue);
+		assertTrue(result);
+		MessageDTO capturedMessage = messageCaptor.getValue();
+		assertNotNull(capturedMessage);
+		assertEquals(Boolean.FALSE, capturedMessage.getIsValid());
+		assertEquals(Boolean.FALSE, capturedMessage.getInternalError());
+	}
+
+	@Test
+	public void testSuccessFlowWhenManualVerificationApprovedShouldSetSuccessStatus() throws com.fasterxml.jackson.core.JsonProcessingException {
+
+		Mockito.when(basePacketRepository.getAssignedVerificationRecord(anyString(), anyString())).thenReturn(entities);
+		String response = objectMapper.writeValueAsString(resp);
+		ActiveMQBytesMessage amq = new ActiveMQBytesMessage();
+		ByteSequence byteSeq = new ByteSequence();
+		byteSeq.setData(response.getBytes());
+		amq.setContent(byteSeq);
+		resp.setReturnValue(1);
+		ArgumentCaptor<MessageDTO> messageCaptor = ArgumentCaptor.forClass(MessageDTO.class);
+		Mockito.doNothing().when(manualAdjudicationStage).sendMessage(messageCaptor.capture());
+		boolean result = verificationService.updatePacketStatus(resp, stageName, queue);
+		assertTrue(result);
+		MessageDTO capturedMessage = messageCaptor.getValue();
+		assertNotNull(capturedMessage);
+		assertEquals(Boolean.TRUE, capturedMessage.getIsValid());
+		assertEquals(Boolean.FALSE, capturedMessage.getInternalError());
+	}
+
 }
diff --git a/registration-processor/registration-processor-message-sender-impl/src/test/java/io/mosip/registration/processor/message/sender/test/service/MessageNotificationServiceImplTest.java b/registration-processor/registration-processor-message-sender-impl/src/test/java/io/mosip/registration/processor/message/sender/test/service/MessageNotificationServiceImplTest.java
index fe3f75c43a9..cdae7e58c82 100644
--- a/registration-processor/registration-processor-message-sender-impl/src/test/java/io/mosip/registration/processor/message/sender/test/service/MessageNotificationServiceImplTest.java
+++ b/registration-processor/registration-processor-message-sender-impl/src/test/java/io/mosip/registration/processor/message/sender/test/service/MessageNotificationServiceImplTest.java
@@ -1,6 +1,7 @@
 package io.mosip.registration.processor.message.sender.test.service;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
@@ -15,9 +16,15 @@
 import java.util.Map;
 
 import io.mosip.registration.processor.core.constant.VidType;
+import io.mosip.registration.processor.core.http.RequestWrapper;
 import io.mosip.registration.processor.core.idrepo.dto.VidInfoDTO;
 import io.mosip.registration.processor.core.idrepo.dto.VidsInfosDTO;
+import io.mosip.registration.processor.packet.manager.decryptor.Decryptor;
 import io.mosip.registration.processor.packet.storage.utils.PacketManagerService;
+import io.mosip.registration.processor.status.dto.SyncRegistrationDto;
+import io.mosip.registration.processor.status.dto.SyncResponseDto;
+import io.mosip.registration.processor.status.entity.SyncRegistrationEntity;
+import io.mosip.registration.processor.status.service.SyncRegistrationService;
 import org.apache.commons.io.IOUtils;
 import org.assertj.core.util.Lists;
 import org.json.JSONException;
@@ -124,6 +131,12 @@ public class MessageNotificationServiceImplTest {
 	@Mock
 	private Environment env;
 
+	@Mock
+	private SyncRegistrationService<SyncResponseDto, SyncRegistrationDto> syncRegistrationService;
+
+	@Mock
+	private Decryptor decryptor;
+
 	/** The attributes. */
 	private Map<String, Object> attributes = new HashMap<>();
 
@@ -165,6 +178,7 @@ public class MessageNotificationServiceImplTest {
 
 	private VidsInfosDTO vidsInfosDTO = new VidsInfosDTO();
 
+
 	/**
 	 * Setup.
 	 *
@@ -489,4 +503,87 @@ public void testSendSmsNotificationSuccessWithExternalType() throws ApisResource
 		verify(packetManagerService,never()).getFields(anyString(),anyList(),anyString(),any());
 	}
 
+	@Test(expected = ApisResourceAccessException.class)
+	public void testSendSmsNotificationWhenTemplateGeneratorFailsShouldThrowApisResourceAccessException() throws IOException, ApisResourceAccessException,
+			PacketDecryptionFailureException, JSONException {
+
+		Mockito.when(templateGenerator.getTemplate(anyString(), any(), anyString())).thenThrow(new ApisResourceAccessException());
+
+		messageNotificationServiceImpl.sendSmsNotification("RPR_UIN_GEN_SMS", "12345", "NEW", IdType.RID, attributes,
+				RegistrationType.NEW.name());
+	}
+
+	@Test
+	public void testSendSmsNotificationWhenPreferredLanguagesSetShouldSendSmsSuccessfully() throws IOException, ApisResourceAccessException,
+			PacketDecryptionFailureException, JSONException, PacketManagerException, JsonProcessingException {
+
+		Mockito.when(packetManagerService.getField(any(), any(), anyString(), any())).thenReturn("EN");
+
+		ResponseWrapper<SmsResponseDto> mockWrapper = new ResponseWrapper<>();
+		SmsResponseDto smsResp = new SmsResponseDto();
+		smsResp.setStatus("OK");
+		mockWrapper.setResponse(smsResp);
+
+		Mockito.when(restClientService.postApi(any(), any(), any(), Mockito.any(RequestWrapper.class),
+				Mockito.eq(ResponseWrapper.class))).thenReturn(mockWrapper);
+
+		SmsResponseDto result = messageNotificationServiceImpl.sendSmsNotification("RPR_UIN_GEN_SMS", "12345", "NEW", IdType.RID, attributes,
+				RegistrationType.NEW.name());
+		assertEquals("OK", result.getStatus());
+	}
+
+	@Test
+	public void testSendSmsNotificationWhenPreferredLanguagesFailShouldStillSendSmsSuccessfully() throws IOException, ApisResourceAccessException,
+			PacketDecryptionFailureException, JSONException, PacketManagerException, JsonProcessingException {
+
+		Mockito.when(packetManagerService.getField(any(), any(), anyString(), any())).thenThrow(new ApisResourceAccessException());
+
+		ResponseWrapper<SmsResponseDto> mockWrapper = new ResponseWrapper<>();
+		SmsResponseDto smsResp = new SmsResponseDto();
+		smsResp.setStatus("OK");
+		mockWrapper.setResponse(smsResp);
+
+		Mockito.when(restClientService.postApi(any(), any(), any(), Mockito.any(RequestWrapper.class),
+				Mockito.eq(ResponseWrapper.class))).thenReturn(mockWrapper);
+
+		SmsResponseDto result = messageNotificationServiceImpl.sendSmsNotification("RPR_UIN_GEN_SMS", "12345", "NEW", IdType.RID, attributes,
+				RegistrationType.NEW.name());
+		assertEquals("OK", result.getStatus());
+	}
+
+	@Test
+	public void testSendSmsNotificationShouldHandleJsonParseExceptionGracefully() throws IOException, ApisResourceAccessException,
+			PacketDecryptionFailureException, JSONException, PacketManagerException, JsonProcessingException {
+
+		SyncRegistrationEntity syncEntity = new SyncRegistrationEntity();
+		syncEntity.setAdditionalInfoReqId(null);
+		syncEntity.setRegistrationType("NEW");
+		syncEntity.setPacketId("2018701130000410092018110735");
+		syncEntity.setWorkflowInstanceId("78fc3d34-03f5-11ec-9a03-0242ac130004");
+		syncEntity.setOptionalValues(new byte[] {1, 2, 3, 4, 5});
+		List<SyncRegistrationEntity> entities = new ArrayList<>();
+		entities.add(syncEntity);
+		SyncRegistrationEntity entity = new SyncRegistrationEntity();
+		entities.add(entity);
+
+		Mockito.when(syncRegistrationService.findByRegistrationId(any())).thenReturn(entities);
+		when(packetManagerService.getFields(anyString(), anyList(), any(), any())).thenReturn(null);
+
+		// Use try-with-resources to ensure FileInputStream is properly closed
+		try (FileInputStream is = new FileInputStream("src/test/resources/1001.zip")) {
+			IOUtils.toByteArray(is);
+			Mockito.when(decryptor.decrypt(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(is);
+
+			ResponseWrapper<SmsResponseDto> mockWrapper = new ResponseWrapper<>();
+			mockWrapper.setResponse(new SmsResponseDto());
+
+			Mockito.when(restClientService.postApi(any(), any(), any(), Mockito.any(RequestWrapper.class),
+					Mockito.eq(ResponseWrapper.class))).thenReturn(mockWrapper);
+
+			SmsResponseDto result = messageNotificationServiceImpl.sendSmsNotification(
+					"RPR_UIN_GEN_SMS", "12345", "NEW", IdType.RID, attributes, RegistrationType.NEW.name());
+			assertNull(result.getStatus());
+		}
+	}
+
 }
diff --git a/registration-processor/registration-processor-message-sender-impl/src/test/resources/1001.zip b/registration-processor/registration-processor-message-sender-impl/src/test/resources/1001.zip
new file mode 100644
index 00000000000..7c5223e7304
Binary files /dev/null and b/registration-processor/registration-processor-message-sender-impl/src/test/resources/1001.zip differ
diff --git a/registration-processor/registration-processor-notification-service/src/test/java/io/mosip/registration/processor/notification/NotificationServiceTest.java b/registration-processor/registration-processor-notification-service/src/test/java/io/mosip/registration/processor/notification/NotificationServiceTest.java
index 241e36edc65..7f2c54afed1 100644
--- a/registration-processor/registration-processor-notification-service/src/test/java/io/mosip/registration/processor/notification/NotificationServiceTest.java
+++ b/registration-processor/registration-processor-notification-service/src/test/java/io/mosip/registration/processor/notification/NotificationServiceTest.java
@@ -2,11 +2,19 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
+import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
+import io.mosip.registration.processor.core.exception.PacketDecryptionFailureException;
+import io.mosip.registration.processor.message.sender.exception.TemplateNotFoundException;
+import io.mosip.registration.processor.packet.storage.utils.Utilities;
+import org.json.JSONException;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -87,6 +95,9 @@ public class NotificationServiceTest {
 	
 	@Mock
 	private Environment env;
+
+	@Mock
+	private Utilities utilities;
 	
 
 	@Before
@@ -810,4 +821,598 @@ public void testMessageConfigurationExceptionForPausedForAdditionalRequest() thr
 		ResponseEntity<Void> res = notificationService.process(workflowPausedForAdditionalInfoEventDTO);
 		assertEquals(200, res.getStatusCodeValue());
 	}
+
+	@Test
+	public void testProcessLostWorkflowUsesEmailWhenSmsFails() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessUinCreatedWorkflowFallbacksToEmailWhenSmsFails() throws Exception {
+
+		Map<String, String> mockMap = new HashMap<>();
+		mockMap.put("CAT1", "PROC1");
+		mockMap.put("CAT2", "PROC2");
+
+		ReflectionTestUtils.setField(notificationService,"additionalProcessCategoryForNotification",mockMap);
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(utilities.getInternalProcess(mockMap, "UIN_CREATED")).thenReturn("NEW");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("UIN_CREATED");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessActivatedWorkflowFallbacksToEmailWhenSmsFails() throws Exception {
+
+		Map<String, String> mockMap = new HashMap<>();
+		mockMap.put("CAT1", "PROC1");
+		mockMap.put("CAT2", "PROC2");
+
+		ReflectionTestUtils.setField(notificationService,"additionalProcessCategoryForNotification",mockMap);
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(utilities.getInternalProcess(mockMap, "ACTIVATED")).thenReturn("UPDATE");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("ACTIVATED");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessDeactivatedWorkflowFallbacksToEmailWhenSmsFails() throws Exception {
+
+		Map<String, String> mockMap = new HashMap<>();
+		mockMap.put("CAT1", "PROC1");
+		mockMap.put("CAT2", "PROC2");
+
+		ReflectionTestUtils.setField(notificationService,"additionalProcessCategoryForNotification",mockMap);
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(utilities.getInternalProcess(mockMap, "DEACTIVATED")).thenReturn("UPDATE");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("DEACTIVATED");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessResUpdateWorkflowFallbackToEmailWhenSmsFails() throws Exception {
+
+		Map<String, String> mockMap = new HashMap<>();
+		mockMap.put("CAT1", "PROC1");
+		mockMap.put("CAT2", "PROC2");
+
+		ReflectionTestUtils.setField(notificationService,"additionalProcessCategoryForNotification",mockMap);
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(utilities.getInternalProcess(mockMap, "RES_UPDATE")).thenReturn("UPDATE");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("RES_UPDATE");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessWhenNotificationTypeIsNone() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "NONE");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> res = notificationService.process(completedEventDTO);
+		assertEquals(200, res.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendSMSSuccess() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "SMS");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendSMSFailed() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "SMS");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendSMSThrowApisResourceAccessException() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "SMS");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendSMSThrowPhoneNumberNotFoundException() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "SMS");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new PhoneNumberNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendEmailSuccess() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "EMAIL");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendEmailFailed() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "EMAIL");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("failed");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendEmailThrowApisResourceAccessException() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "EMAIL");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new ApisResourceAccessException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessNotificationTypesSendEmailThrowEmailIdNotFoundException() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "EMAIL");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("failed");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenReturn(smsResponse);
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenThrow(new EmailIdNotFoundException());
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+
+		String s = templateResponseDto.toString();
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn(s);
+		Mockito.when(mapper.readValue(anyString(), any(Class.class))).thenReturn(templateResponseDto);
+
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
+	@Test
+	public void testProcessSendNotificationThrowTemplateNotFoundException() throws Exception {
+
+		ReflectionTestUtils.setField(notificationService, "notificationTypes", "FAX");
+		List<TemplateDto> templates = new ArrayList<TemplateDto>();
+		TemplateDto templateEmail = new TemplateDto();
+		TemplateDto templateSMS = new TemplateDto();
+		TemplateResponseDto templateResponseDto = new TemplateResponseDto();
+		templateSMS.setTemplateTypeCode("RPR_LOST_UIN_SMS");
+		templates.add(templateSMS);
+		templateEmail.setTemplateTypeCode("RPR_LOST_UIN_EMAIL");
+		templates.add(templateEmail);
+		templateResponseDto.setTemplates(templates);
+		ResponseWrapper<TemplateResponseDto> responseWrapper=new ResponseWrapper<>();
+		responseWrapper.setResponse(templateResponseDto);
+		responseWrapper.setErrors(null);
+		SmsResponseDto smsResponse = new SmsResponseDto();
+		smsResponse.setStatus("success");
+		ResponseDto responseDto = new ResponseDto();
+		responseDto.setStatus("success");
+		Mockito.when(env.getProperty(any())).thenReturn("RPR_LOST_UIN_SMS").thenReturn("RPR_LOST_UIN_EMAIL")
+				.thenReturn("RPR_UIN_GEN_EMAIL_SUB");
+
+		when(service.sendSmsNotification(any(), any(), any(), any(), any(), any())).thenThrow(new TemplateNotFoundException());
+		when(service.sendEmailNotification(any(), any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(responseDto);
+		when(restClientService.getApi(Mockito.eq(ApiName.TEMPLATES), any(), Mockito.eq(""), Mockito.eq(""), Mockito.eq(ResponseWrapper.class))).thenReturn(responseWrapper);
+		WorkflowCompletedEventDTO completedEventDTO = new WorkflowCompletedEventDTO();
+		completedEventDTO.setInstanceId("85425022110000120190117110505");
+		completedEventDTO.setResultCode("PROCESSED");
+		completedEventDTO.setWorkflowType("LOST");
+
+		ResponseEntity<Void> result = notificationService.process(completedEventDTO);
+		assertEquals(200, result.getStatusCodeValue());
+	}
+
 	}
diff --git a/registration-processor/registration-processor-packet-manager/src/test/java/io/mosip/registration/processor/packet/manager/service/impl/test/IdRepoServiceImplTest.java b/registration-processor/registration-processor-packet-manager/src/test/java/io/mosip/registration/processor/packet/manager/service/impl/test/IdRepoServiceImplTest.java
index 6400c7f2030..9dee051f770 100644
--- a/registration-processor/registration-processor-packet-manager/src/test/java/io/mosip/registration/processor/packet/manager/service/impl/test/IdRepoServiceImplTest.java
+++ b/registration-processor/registration-processor-packet-manager/src/test/java/io/mosip/registration/processor/packet/manager/service/impl/test/IdRepoServiceImplTest.java
@@ -1,5 +1,6 @@
 package io.mosip.registration.processor.packet.manager.service.impl.test;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyList;
@@ -7,6 +8,8 @@
 
 import javax.swing.text.Utilities;
 
+import io.mosip.registration.processor.core.code.ApiName;
+import io.mosip.registration.processor.core.idrepo.dto.ResponseDTO;
 import org.apache.commons.io.IOUtils;
 import org.json.simple.JSONObject;
 import org.junit.Before;
@@ -21,7 +24,6 @@
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
-import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import io.mosip.registration.processor.core.http.ResponseWrapper;
@@ -129,4 +131,63 @@ public void testfindUinFromIdrepo() throws Exception {
 		assertNull(matchedDemographicIdentity);
 
 	}
+
+	@Test
+	public void testGetIdJsonFromIDRepoWhenResponseNotNull() throws Exception {
+		IdResponseDTO dto = new IdResponseDTO();
+		dto.setId("123333");
+		dto.setVersion("v1");
+		dto.setTimestamp("2025-12-11T18:10:00Z");
+		ResponseDTO responseDTO = new ResponseDTO();
+		dto.setResponse(responseDTO);
+		ResponseWrapper<IdResponseDTO> response = new ResponseWrapper<>();
+		response.setResponse(dto);
+
+		Mockito.when(restClientService.getApi(
+						Mockito.eq(ApiName.RETRIEVEIDENTITYFROMRID),
+						anyList(),
+						anyString(),
+						anyString(),
+						Mockito.eq(ResponseWrapper.class)))
+				.thenReturn(response);
+
+		Mockito.when(mapper.writeValueAsString(any())).thenReturn("{\"Identity\":{\"UIN\":\"1234\"}}");
+
+		JSONObject identity = new JSONObject();
+		JSONObject demo = new JSONObject();
+		demo.put("UIN", "1234");
+		identity.put("Identity", demo);
+
+		PowerMockito.mockStatic(JsonUtil.class);
+		PowerMockito.when(JsonUtil.objectMapperReadValue(anyString(), Mockito.eq(JSONObject.class)))
+				.thenReturn(identity);
+
+		PowerMockito.when(JsonUtil.getJSONObject(identity, "Identity"))
+				.thenReturn(demo);
+		JSONObject result = idRepoService.getIdJsonFromIDRepo("123", "Identity");
+		assertEquals("1234", result.get("UIN"));
+	}
+
+	@Test
+	public void testGetIdJsonFromIDRepoWhenResponseNull() throws Exception {
+
+		ResponseWrapper<IdResponseDTO> response = new ResponseWrapper<>();
+		response.setResponse(null);
+
+		Mockito.when(restClientService.getApi(any(), anyList(), anyString(), anyString(), any()))
+				.thenReturn(response);
+		JSONObject result = idRepoService.getIdJsonFromIDRepo("123", "Identity");
+		assertNull(result);
+	}
+
+	@Test
+	public void testGetIdResponseFromIDRepoWhenResponseNull() throws Exception {
+		ResponseWrapper<ResponseDTO> response = new ResponseWrapper<>();
+		response.setResponse(null);
+
+		Mockito.when(restClientService.getApi(any(), anyList(), anyString(), anyString(), any()))
+				.thenReturn(response);
+		ResponseDTO result = idRepoService.getIdResponseFromIDRepo("123");
+		assertNull(result);
+	}
 }