From 99feb337cb9900cc7fb010a25e1798cfae09ec4f Mon Sep 17 00:00:00 2001 From: GOKULRAJ136 <110164849+GOKULRAJ136@users.noreply.github.com> Date: Mon, 8 Jul 2024 16:23:29 +0530 Subject: [PATCH 01/11] newly added test cases Signed-off-by: GOKULRAJ136 <110164849+GOKULRAJ136@users.noreply.github.com> --- .../batch/CustomExcelRowMapperTest.java | 126 ++++++++ .../batch/RepositoryListItemWriterTest.java | 183 +++++++++++ .../BulkDataUploadServiceImplTest.java | 181 +++++++++++ .../util/RestClientTest.java | 223 ++++++++++++++ .../test/service/HolidayServiceImplTest.java | 128 ++++++++ .../RegistrationCenterServiceImplTest.java | 202 +++++++++++++ .../masterdata/test/utils/CacheNameTest.java | 50 +++ .../test/utils/DeviceUtilsTest.java | 102 +++++++ .../test/utils/FieldComparatorTest.java | 170 +++++++++++ .../RegistrationCenterValidatorTest.java | 63 ++++ .../masterdata/test/utils/RestClientTest.java | 192 ++++++++++++ .../test/validator/FieldValidatorTest.java | 87 ++++++ .../validator/FoundationalValidatorTest.java | 125 ++++++++ .../test/validator/TypeValidatorTest.java | 57 ++++ .../SyncConfigDetailsServiceImplTest.java | 285 ++++++++++++++++++ .../service/SyncJobHelperServiceTest.java | 170 +++++++++++ 16 files changed, 2344 insertions(+) create mode 100644 admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/CustomExcelRowMapperTest.java create mode 100644 admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/RepositoryListItemWriterTest.java create mode 100644 admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/service/BulkDataUploadServiceImplTest.java create mode 100644 admin/admin-service/src/test/java/io/mosip/admin/packetstatusupdater/util/RestClientTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/HolidayServiceImplTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/RegistrationCenterServiceImplTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/CacheNameTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/DeviceUtilsTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/FieldComparatorTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RegistrationCenterValidatorTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RestClientTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FieldValidatorTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FoundationalValidatorTest.java create mode 100644 admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/TypeValidatorTest.java create mode 100644 admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncConfigDetailsServiceImplTest.java create mode 100644 admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncJobHelperServiceTest.java diff --git a/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/CustomExcelRowMapperTest.java b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/CustomExcelRowMapperTest.java new file mode 100644 index 00000000000..9ff47a132d0 --- /dev/null +++ b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/CustomExcelRowMapperTest.java @@ -0,0 +1,126 @@ +package io.mosip.admin.bulkdataupload.batch; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.batch.extensions.excel.support.rowset.RowSet; +import org.springframework.beans.NotWritablePropertyException; +import org.springframework.boot.convert.ApplicationConversionService; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebApplicationContext; +import org.springframework.format.support.DefaultFormattingConversionService; +import org.springframework.validation.BindException; +import org.springframework.validation.DataBinder; +import org.springframework.validation.DefaultBindingErrorProcessor; +import org.springframework.validation.beanvalidation.CustomValidatorBean; + +import javax.validation.ConstraintViolationException; +import java.util.HashSet; +import java.util.Properties; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class CustomExcelRowMapperTest { + + @Test + public void createBinder_withApplicationConversionService_returnSuccessResponse() { + ApplicationConversionService conversionService = new ApplicationConversionService(); + DataBinder actualCreateBinderResult = (new CustomExcelRowMapper<>(conversionService, new CustomValidatorBean())) + .createBinder("Target"); + + assertNotNull(actualCreateBinderResult); + assertFalse(actualCreateBinderResult.isIgnoreUnknownFields()); + assertFalse(actualCreateBinderResult.isIgnoreInvalidFields()); + assertTrue(actualCreateBinderResult.isAutoGrowNestedPaths()); + assertNull(actualCreateBinderResult.getValidator()); + assertEquals("Target", actualCreateBinderResult.getTarget()); + assertEquals("target", actualCreateBinderResult.getObjectName()); + assertTrue(actualCreateBinderResult.getBindingErrorProcessor() instanceof DefaultBindingErrorProcessor); + assertEquals(256, actualCreateBinderResult.getAutoGrowCollectionLimit()); + } + + @Test + public void createBinder_withDefaultFormattingConversionService_returnSuccessResponse() { + DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService(); + + DataBinder actualCreateBinderResult = (new CustomExcelRowMapper<>(conversionService, new CustomValidatorBean())) + .createBinder("Target"); + + assertNotNull(actualCreateBinderResult); + assertFalse(actualCreateBinderResult.isIgnoreUnknownFields()); + assertFalse(actualCreateBinderResult.isIgnoreInvalidFields()); + assertTrue(actualCreateBinderResult.isAutoGrowNestedPaths()); + assertNull(actualCreateBinderResult.getValidator()); + assertEquals("Target", actualCreateBinderResult.getTarget()); + assertEquals("target", actualCreateBinderResult.getObjectName()); + assertTrue(actualCreateBinderResult.getBindingErrorProcessor() instanceof DefaultBindingErrorProcessor); + assertEquals(256, actualCreateBinderResult.getAutoGrowCollectionLimit()); + } + + @Test + public void customExcelRowMapper_withSetValues_returnSuccessResponse() { + ApplicationConversionService conversionService = new ApplicationConversionService(); + CustomExcelRowMapper actualCustomExcelRowMapper = new CustomExcelRowMapper<>(conversionService, + new CustomValidatorBean()); + actualCustomExcelRowMapper.setBeanFactory(new AnnotationConfigReactiveWebApplicationContext()); + actualCustomExcelRowMapper.setDistanceLimit(1); + actualCustomExcelRowMapper.setPrototypeBeanName("Name"); + actualCustomExcelRowMapper.setStrict(true); + actualCustomExcelRowMapper.setTargetType(Object.class); + DataBinder dataBinder = new DataBinder("Target", "Object Name"); + actualCustomExcelRowMapper.initBinder(dataBinder); + assertNotNull(dataBinder); + } + + @Test + public void customExcelRowMapper_withInitBinder_returnSuccessResponse() { + ApplicationConversionService conversionService = new ApplicationConversionService(); + CustomExcelRowMapper actualCustomExcelRowMapper = new CustomExcelRowMapper<>(conversionService, + new CustomValidatorBean()); + DataBinder dataBinder = new DataBinder("Target", "Object Name"); + actualCustomExcelRowMapper.initBinder(dataBinder); + assertNotNull(dataBinder); + } + + @Test(expected = Exception.class) + public void mapRow_withEmptyRowSet_throwException() throws BindException { + ApplicationConversionService conversionService = new ApplicationConversionService(); + CustomExcelRowMapper customExcelRowMapper = new CustomExcelRowMapper<>(conversionService, + new CustomValidatorBean()); + customExcelRowMapper.setTargetType(Object.class); + RowSet rowSet = mock(RowSet.class); + when(rowSet.getProperties()).thenReturn(new Properties()); + customExcelRowMapper.mapRow(rowSet); + } + + @Test(expected = NotWritablePropertyException.class) + public void mapRow_withProperties_throwNotWritablePropertyException() throws BindException { + ApplicationConversionService conversionService = new ApplicationConversionService(); + CustomExcelRowMapper customExcelRowMapper = new CustomExcelRowMapper<>(conversionService, + new CustomValidatorBean()); + customExcelRowMapper.setTargetType(Object.class); + + Properties properties = new Properties(); + properties.setProperty("key", "value"); + RowSet rowSet = mock(RowSet.class); + when(rowSet.getProperties()).thenReturn(properties); + customExcelRowMapper.mapRow(rowSet); + } + + @Test(expected = ConstraintViolationException.class) + public void mapRow_withConstraintViolation_throwConstraintViolationException() throws BindException { + ApplicationConversionService conversionService = new ApplicationConversionService(); + CustomExcelRowMapper customExcelRowMapper = new CustomExcelRowMapper<>(conversionService, + new CustomValidatorBean()); + customExcelRowMapper.setTargetType(Object.class); + RowSet rowSet = mock(RowSet.class); + when(rowSet.getProperties()).thenThrow(new ConstraintViolationException(new HashSet<>())); + customExcelRowMapper.mapRow(rowSet); + + } + +} diff --git a/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/RepositoryListItemWriterTest.java b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/RepositoryListItemWriterTest.java new file mode 100644 index 00000000000..975decec671 --- /dev/null +++ b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/RepositoryListItemWriterTest.java @@ -0,0 +1,183 @@ +package io.mosip.admin.bulkdataupload.batch; + +import io.mosip.admin.config.Mapper; +import io.mosip.kernel.core.dataaccess.spi.repository.BaseRepository; +import jakarta.persistence.EntityManager; +import jakarta.persistence.EntityManagerFactory; +import jakarta.persistence.PersistenceUnitUtil; +import org.apache.poi.ss.formula.functions.T; +import org.junit.Before; +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.batch.core.JobExecutionException; +import org.springframework.batch.item.Chunk; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.context.ApplicationContext; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertThrows; +import static org.mockito.Mockito.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class RepositoryListItemWriterTest { + + @InjectMocks + private RepositoryListItemWriter writer; + + @Mock + private EntityManager em; + + @Mock + private EntityManagerFactory emf; + + @Mock + private PersistenceUnitUtil util; + + @Mock + private ApplicationContext applicationContext; + + @Mock + private BaseRepository baseRepository; + + @Mock + private Mapper mapper; + + private T entity1; + private T entity2; + + @Before + public void setUp() { + writer = new RepositoryListItemWriter<>(em, emf, T.class, mapper, applicationContext); + writer.setMethodName("save"); + writer.setRepoBeanName("mockRepo"); + writer.setOperation("insert"); + + entity1 = new T(); + entity2 = new T(); + } + + @Test + public void testWrite_EmptyChunk() throws Exception { + Chunk emptyChunk = new Chunk<>(new ArrayList<>()); + writer.write(emptyChunk); + } + + @Test + public void testWrite_InsertSuccess() { + List entities = new ArrayList<>(); + entities.add(entity1); + entities.add(entity2); + + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(util.getIdentifier(entity2)).thenReturn(2); + lenient().when(em.find(T.class, 1)).thenReturn(null); + lenient().when(em.find(T.class, 2)).thenReturn(null); + } + + @Test + public void testWrite_InsertDuplicate() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(em.find(T.class, 1)).thenReturn(entity1); + + assertThrows(JobExecutionException.class, () -> writer.write(chunk)); + + verify(applicationContext).getBean("mockRepo"); + verify(baseRepository, never()).save(entity1); + } + + @Test + public void testWrite_UpdateSuccess() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + writer.setOperation("update"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(em.find(T.class, 1)).thenReturn(entity1); + } + + @Test + public void testWrite_UpdateNotFound() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + writer.setOperation("update"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(em.find(T.class, 1)).thenReturn(null); + + assertThrows(JobExecutionException.class, () -> writer.write(chunk)); + + verify(applicationContext).getBean("mockRepo"); + verify(baseRepository, never()).save(entity1); + } + + @Test + public void testWrite_DeleteSuccess() { + List entities = new ArrayList<>(); + entities.add(entity1); + + writer.setOperation("delete"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(em.find(T.class, 1)).thenReturn(entity1); + } + + @Test + public void testWrite_DeleteNotFound() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + writer.setOperation("delete"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + lenient().when(em.find(T.class, 1)).thenReturn(null); + + assertThrows(JobExecutionException.class, () -> writer.write(chunk)); + + verify(applicationContext).getBean("mockRepo"); + verify(baseRepository, never()).save(entity1); + } + + @Test + public void testWrite_RepositoryException() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + writer.setOperation("insert"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + + assertThrows(JobExecutionException.class, () -> writer.write(chunk)); + } + + @Test + public void testWrite_UnexpectedException() { + List entities = new ArrayList<>(); + entities.add(entity1); + Chunk chunk = new Chunk<>(entities); + + writer.setOperation("insert"); + lenient().when(applicationContext.getBean("mockRepo")).thenReturn(baseRepository); + lenient().when(util.getIdentifier(entity1)).thenReturn(1); + + assertThrows(JobExecutionException.class, () -> writer.write(chunk)); + } + +} diff --git a/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/service/BulkDataUploadServiceImplTest.java b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/service/BulkDataUploadServiceImplTest.java new file mode 100644 index 00000000000..2ca9112f0c4 --- /dev/null +++ b/admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/service/BulkDataUploadServiceImplTest.java @@ -0,0 +1,181 @@ +package io.mosip.admin.bulkdataupload.service; + +import io.mosip.admin.bulkdataupload.dto.BulkDataResponseDto; +import io.mosip.admin.bulkdataupload.entity.BaseEntity; +import io.mosip.admin.bulkdataupload.entity.BulkUploadTranscation; +import io.mosip.admin.bulkdataupload.repositories.BulkUploadTranscationRepository; +import io.mosip.admin.bulkdataupload.service.impl.BulkDataUploadServiceImpl; +import io.mosip.admin.packetstatusupdater.exception.RequestException; +import io.mosip.admin.packetstatusupdater.util.AuditUtil; +import io.mosip.admin.packetstatusupdater.util.EventEnum; +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.batch.core.Job; +import org.springframework.batch.core.launch.JobLauncher; +import org.springframework.batch.extensions.excel.poi.PoiItemReader; +import org.springframework.batch.item.ItemProcessor; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.web.multipart.MultipartFile; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class BulkDataUploadServiceImplTest { + + @InjectMocks + private BulkDataUploadServiceImpl service; + + @Mock + private AuditUtil auditUtil; + + @Mock + private JobLauncher jobLauncher; + + @Mock + private MultipartFile file; + + @Mock + private BulkUploadTranscationRepository bulkTranscationRepo; + + @Test (expected = RequestException.class) + public void testImportDataFromFile_InvalidTable() throws Exception { + String tableName = "TABLENAME"; + String operation = "insert"; + String category = "test_category"; + Map entityMap = new HashMap<>(); + entityMap.put(tableName, Object.class); + Class entityClass = Object.class; + + lenient().when(file.isEmpty()).thenReturn(false); + lenient().when(file.getOriginalFilename()).thenReturn("test.csv"); + lenient().when(jobLauncher.run(any(Job.class), any())).thenReturn(null); + BulkUploadTranscation transaction = new BulkUploadTranscation(); + + ReflectionTestUtils.invokeMethod(service, "saveTranscationDetails", 0, operation, entityClass.getSimpleName(), category, "", "PROCESSING"); + + BulkDataResponseDto response = ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, new MultipartFile[]{file}); + + assert response != null; + assertEquals(response.getTranscationId(), transaction.getId()); + verify(auditUtil).setAuditRequestDto(EventEnum.getEventEnumWithValue(EventEnum.BULKDATA_UPLOAD, + "{category:'" + category + "',tablename:'" + tableName + "',operation:'" + operation + "'}"), null); + } + + @Test + public void testImportDataFromFile_emptyFile_throwsException() { + String tableName = "test_table"; + String operation = "insert"; + String category = "test_category"; + lenient().when(file.isEmpty()).thenReturn(true); + + assertThrows(RequestException.class, () -> ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, new MultipartFile[]{file})); + verify(auditUtil).setAuditRequestDto(EventEnum.BULKDATA_INVALID_ARGUMENT, null); + } + + @Test + public void testImportDataFromFile_invalidFileFormat_throwsException() { + String tableName = "test_table"; + String operation = "insert"; + String category = "test_category"; + lenient().when(file.isEmpty()).thenReturn(false); + lenient().when(file.getOriginalFilename()).thenReturn("test.txt"); + + assertThrows(RequestException.class, () -> ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, new MultipartFile[]{file})); + verify(auditUtil).setAuditRequestDto(EventEnum.BULKDATA_INVALID_ARGUMENT, null); + } + + @Test + public void testImportDataFromFile_nullFileArray_throwsException() { + String tableName = "test_table"; + String operation = "insert"; + String category = "test_category"; + + assertThrows(RequestException.class, () -> ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, null)); + verify(auditUtil).setAuditRequestDto(EventEnum.BULKDATA_INVALID_ARGUMENT, null); + } + + @Test + public void testImportDataFromFile_invalidOperation_throwsException() { + String tableName = "test_table"; + String operation = "invalid"; + String category = "test_category"; + + assertThrows(RequestException.class, () -> ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, new MultipartFile[]{file})); + verify(auditUtil).setAuditRequestDto(EventEnum.BULKDATA_INVALID_OPERATION, null); + } + + @Test (expected = RequestException.class) + public void testImportDataFromFile_RequestException_updatesTransaction() { + String tableName = "TABLENAME"; + String operation = "insert"; + String category = "test_category"; + Map entityMap = new HashMap<>(); + entityMap.put(tableName, Object.class); + Class entityClass = Object.class; + + lenient().when(file.isEmpty()).thenReturn(false); + lenient().when(file.getOriginalFilename()).thenReturn("test.csv"); + BulkUploadTranscation transaction = new BulkUploadTranscation(); + + ReflectionTestUtils.invokeMethod(service, "saveTranscationDetails", 0, operation, entityClass.getSimpleName(), category, "", "PROCESSING"); + + ReflectionTestUtils.invokeMethod(service, "importDataFromFile", tableName, operation, category, new MultipartFile[]{file}); + + verify(auditUtil).setAuditRequestDto(EventEnum.getEventEnumWithValue(EventEnum.BULKDATA_UPLOAD_COMPLETED, + transaction.getId() + " --> FAILED: 0, MESSAGE: IOException"), null); + } + + @Test + public void testUpdateBulkUploadTransaction_setsFieldsCorrectly() { + BulkUploadTranscation transaction = new BulkUploadTranscation(); + ReflectionTestUtils.invokeMethod(service, "updateBulkUploadTransaction", transaction); + + assertEquals("COMPLETED", transaction.getStatusCode()); + assertTrue(transaction.getUploadedDateTime().toInstant().isBefore(Instant.now())); + assertEquals("JOB", transaction.getUpdatedBy()); + verify(bulkTranscationRepo).save(transaction); + } + + @Test (expected = IllegalArgumentException.class) + public void testExcelItemReader_setsPropertiesInCorrectly() throws Exception { + String filename = "test.xlsx"; + Class clazz = Object.class; + MultipartFile mockFile = mock(MultipartFile.class); + lenient().when(mockFile.isEmpty()).thenReturn(false); + lenient().when(mockFile.getOriginalFilename()).thenReturn(filename); + + PoiItemReader reader = ReflectionTestUtils.invokeMethod(service, "excelItemReader", mockFile, clazz); + + assert reader != null; + assertEquals("Excel-Reader", reader.getName()); + verify(mockFile).getInputStream(); + } + + @Test + public void testProcessor_insertOperation_setsCreatedFields() throws Exception { + String operation = "insert"; + String user = "test_user"; + BaseEntity entity = new BaseEntity(); + + ItemProcessor processor = ReflectionTestUtils.invokeMethod(service, "processor", operation, user); + Object processedEntity = processor.process(entity); + + assert processedEntity != null; + assertEquals(user, ((BaseEntity) processedEntity).getCreatedBy()); + assertTrue(((BaseEntity) processedEntity).getCreatedDateTime().isBefore(LocalDateTime.now())); + assertFalse(((BaseEntity) processedEntity).getIsDeleted()); + } + +} diff --git a/admin/admin-service/src/test/java/io/mosip/admin/packetstatusupdater/util/RestClientTest.java b/admin/admin-service/src/test/java/io/mosip/admin/packetstatusupdater/util/RestClientTest.java new file mode 100644 index 00000000000..498b1cbd9f8 --- /dev/null +++ b/admin/admin-service/src/test/java/io/mosip/admin/packetstatusupdater/util/RestClientTest.java @@ -0,0 +1,223 @@ +package io.mosip.admin.packetstatusupdater.util; + +import io.mosip.admin.packetstatusupdater.constant.ApiName; +import io.mosip.admin.packetstatusupdater.exception.MasterDataServiceException; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.core.env.Environment; +import org.springframework.http.*; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.web.client.RestTemplate; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +@SpringBootTest +@ContextConfiguration(classes = {RestClient.class}) +@RunWith(SpringRunner.class) +public class RestClientTest { + + @MockBean + private Environment environment; + + @Autowired + private RestClient restClient; + + @MockBean + private RestTemplate restTemplate; + + @Test + public void postApi_withValidInput_thenSuccess() throws Exception { + + ApiName apiName = ApiName.MACHINE_GET_API; + List pathsegments =List.of("hi","hello","welcome"); + String queryParamName = "name"; + String queryParamValue = "value"; + MediaType mediaType = mock(MediaType.class); + Object requestType = mock(Object.class); + Class responseType = Class.class; + + restClient.postApi(apiName,pathsegments,queryParamName,queryParamValue,mediaType,requestType,responseType); + assertNotNull(requestType); + } + + @Test + public void postApi_withRetrieveApi_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + + assertEquals("Post For Object", restClient.postApi(ApiName.RETRIEVE_IDENTITY_API, pathsegments, + "Query Param Name", "42", null, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void postApi_withLostRIDApi_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + + ArrayList stringList = new ArrayList<>(); + stringList.add("RestClientTest"); + + assertEquals("Post For Object", restClient.postApi(ApiName.LOST_RID_API, stringList, "Query Param Name", "42", + null, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void postApi_withMediaType_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + MediaType mediaType = mock(MediaType.class); + + assertEquals("Post For Object", restClient.postApi(ApiName.LOST_RID_API, pathsegments, "Query Param Name", "42", + mediaType, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void postApi_withHttpEntity_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + + HttpEntity httpEntity = mock(HttpEntity.class); + when(httpEntity.getBody()).thenThrow(new ClassCastException()); + when(httpEntity.getHeaders()).thenReturn(new HttpHeaders()); + + assertEquals("Post For Object", restClient.postApi(ApiName.LOST_RID_API, pathsegments, "Query Param Name", "42", + null, httpEntity, Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + verify(httpEntity).getBody(); + verify(httpEntity).getHeaders(); + } + + @Test + public void postApi_onlyWithRequestType_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + assertEquals("Post For Object", restClient.postApi(ApiName.LOST_RID_API, null, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test (expected = MasterDataServiceException.class) + public void postApi_withoutPostForObject_returnErrorResponse() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenThrow(new MasterDataServiceException("An error occurred", "An error occurred")); + restClient.postApi(ApiName.LOST_RID_API, null, "Request Type", Object.class); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void getApi_withValidInput_thenSuccess() throws Exception { + ApiName apiName = ApiName.MACHINE_GET_API; + List pathsegments = List.of("hi","hello","welcome"); + String queryParamName = "name"; + String queryParamValue = "value"; + Class responseType = Class.class; + + restClient.getApi(apiName,pathsegments,queryParamName,queryParamValue,responseType); + assertNotNull(pathsegments); + } + + @Test + public void getApi_withLostRIDAPI_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.exchange(any(), any(), any(), (Class) any())) + .thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + ArrayList pathsegments = new ArrayList<>(); + + assertNull(restClient.getApi(ApiName.LOST_RID_API, pathsegments, "Query Param Name", "42", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).exchange(any(), any(), any(), (Class) any()); + } + + @Test + public void getApi_withHttpURL_thenSuccess() throws Exception { + when(restTemplate.exchange(any(), any(), any(), (Class) any(), + (Object[]) any())).thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + assertNull(restClient.getApi("https://dev.mosip.net", Object.class)); + verify(restTemplate).exchange(any(), any(), any(), (Class) any(), (Object[]) any()); + } + + + @Test + public void getApi_withMachineGetAPI_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.exchange(any(), any(), any(), (Class) any())) + .thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + + ArrayList stringList = new ArrayList<>(); + stringList.add("RestClientTest"); + + assertNull(restClient.getApi(ApiName.MACHINE_GET_API, stringList, "Query Param Name", "42", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).exchange(any(), any(), any(), (Class) any()); + } + + @Test (expected = Exception.class) + public void getApi_withHttpURL_returnErrorResponse() throws Exception { + ResponseEntity responseEntity = mock(ResponseEntity.class); + when(responseEntity.getBody()) + .thenThrow(new MasterDataServiceException("An error occurred", "An error occurred")); + when(restTemplate.exchange(any(), any(), any(), (Class) any(), + (Object[]) any())).thenReturn(responseEntity); + restClient.getApi("https://dev.mosip.net/", Object.class); + verify(restTemplate).exchange(any(), any(), any(), (Class) any(), (Object[]) any()); + verify(responseEntity).getBody(); + } + + @Test + public void setRequestHeader_withValidInput_thenSuccess() { + + Object requestType = mock(Object.class); + MediaType mediaType = mock(MediaType.class); + + ReflectionTestUtils.invokeMethod(restClient,"setRequestHeader",requestType,mediaType); + assertNotNull(requestType); + } + + @Test + public void setRequestHeader_withHttpURL_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + MediaType mediaType = mock(MediaType.class); + + HttpHeaders httpHeaders = new HttpHeaders(); + httpHeaders.add("https://dev.mosip.net/", "https://dev.mosip.net/"); + HttpEntity httpEntity = (HttpEntity) mock(HttpEntity.class); + when(httpEntity.getBody()).thenThrow(new ClassCastException()); + when(httpEntity.getHeaders()).thenReturn(httpHeaders); + + assertEquals("Post For Object", restClient.postApi(ApiName.MACHINE_GET_API, pathsegments, "Query Param Name", + "42", mediaType, httpEntity, Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + verify(httpEntity).getBody(); + verify(httpEntity).getHeaders(); + } +} \ No newline at end of file diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/HolidayServiceImplTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/HolidayServiceImplTest.java new file mode 100644 index 00000000000..8cfa7f515ab --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/HolidayServiceImplTest.java @@ -0,0 +1,128 @@ +package io.mosip.kernel.masterdata.test.service; + +import io.mosip.kernel.masterdata.dto.HolidayIDDto; +import io.mosip.kernel.masterdata.dto.HolidayUpdateDto; +import io.mosip.kernel.masterdata.dto.getresponse.extn.HolidayExtnDto; +import io.mosip.kernel.masterdata.dto.request.SearchFilter; +import io.mosip.kernel.masterdata.dto.response.HolidaySearchDto; +import io.mosip.kernel.masterdata.entity.Location; +import io.mosip.kernel.masterdata.service.impl.HolidayServiceImpl; +import io.mosip.kernel.masterdata.validator.FilterTypeEnum; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.util.ReflectionTestUtils; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.*; + +import static org.junit.Assert.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class HolidayServiceImplTest { + + @InjectMocks + HolidayServiceImpl holidayService; + + private HolidayUpdateDto holidayUpdateDto; + private Location location; + + @Before + public void setUp() { + holidayUpdateDto = new HolidayUpdateDto(); + holidayUpdateDto.setHolidayId(1); + holidayUpdateDto.setHolidayDesc("Test Description"); + holidayUpdateDto.setHolidayDate(LocalDate.from(LocalDateTime.now())); + holidayUpdateDto.setHolidayName("Test Holiday"); + holidayUpdateDto.setLocationCode("LOC123"); + holidayUpdateDto.setLangCode("en"); + + location = new Location(); + location.setCode("LOC123"); + } + + @Test + public void testBindDtoToMap() { + Map expectedMap = new HashMap<>(); + expectedMap.put("holidayId", 1L); + expectedMap.put("holidayDesc", "Test Description"); + expectedMap.put("holidayDate", LocalDateTime.now()); + expectedMap.put("holidayName", "Test Holiday"); + expectedMap.put("locationCode", "LOC123"); + expectedMap.put("langCode", "en"); + expectedMap.put("updatedDateTime", LocalDateTime.now(ZoneId.of("UTC"))); + + assertThrows(NullPointerException.class, () -> ReflectionTestUtils.invokeMethod(holidayService, "bindDtoToMap", holidayUpdateDto)); + } + + @Test + public void testMapToHolidayIdDto() { + HolidayIDDto expectedDto = new HolidayIDDto(); + expectedDto.setHolidayId(1); + expectedDto.setHolidayName("Test Holiday"); + expectedDto.setHolidayDate(LocalDate.from(LocalDateTime.now())); + expectedDto.setLocationCode("LOC123"); + expectedDto.setLangCode("en"); + + HolidayIDDto resultDto = ReflectionTestUtils.invokeMethod(holidayService, "mapToHolidayIdDto", holidayUpdateDto); + + assertNotNull(resultDto); + assertEquals(expectedDto, resultDto); + } + + @Test + public void testBuildLocationSearchFilter_EmptyList() { + List emptyList = Collections.emptyList(); + List filters = ReflectionTestUtils.invokeMethod(holidayService, "buildLocationSearchFilter", emptyList); + + assertNotNull(filters); + assertEquals(0, filters.size()); + } + + @Test + public void testBuildLocationSearchFilter_ValidList() { + List locations = new ArrayList<>(); + locations.add(location); + List expectedFilters = Collections.singletonList(buildExpectedSearchFilter()); + + List filters = ReflectionTestUtils.invokeMethod(holidayService, "buildLocationSearchFilter", locations); + + assertNotNull(filters); + assertEquals(expectedFilters, filters); + } + + @Test + public void testSetMetaData() { + List holidays = new ArrayList<>(); + List locations = new ArrayList<>(); + locations.add(location); + HolidayExtnDto holiday1 = new HolidayExtnDto(); + holiday1.setLocationCode("LOC123"); + holidays.add(holiday1); + HolidayExtnDto holiday2 = new HolidayExtnDto(); + holiday2.setLocationCode("LOC456"); + holidays.add(holiday2); + + HolidaySearchDto searchDto = new HolidaySearchDto(); + + ReflectionTestUtils.invokeMethod(holidayService, "setMetaData", holidays, locations, searchDto); + + assertNotNull(holidays); + assertNotNull(locations); + } + + private SearchFilter buildExpectedSearchFilter() { + SearchFilter filter = new SearchFilter(); + filter.setColumnName("locationCode"); + filter.setType(FilterTypeEnum.EQUALS.name()); + filter.setValue("LOC123"); + return filter; + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/RegistrationCenterServiceImplTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/RegistrationCenterServiceImplTest.java new file mode 100644 index 00000000000..24809d94582 --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/service/RegistrationCenterServiceImplTest.java @@ -0,0 +1,202 @@ +package io.mosip.kernel.masterdata.test.service; + +import io.mosip.kernel.masterdata.dto.RegCenterPutReqDto; +import io.mosip.kernel.masterdata.dto.request.SearchFilter; +import io.mosip.kernel.masterdata.entity.*; +import io.mosip.kernel.masterdata.repository.*; +import io.mosip.kernel.masterdata.service.impl.RegistrationCenterServiceImpl; +import io.mosip.kernel.masterdata.entity.RegistrationCenter; +import io.mosip.kernel.masterdata.utils.*; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.util.ReflectionTestUtils; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class RegistrationCenterServiceImplTest { + + @InjectMocks + private RegistrationCenterServiceImpl registrationCenterServiceImpl; + + @Mock + private RegistrationCenterHistoryRepository registrationCenterHistoryRepository; + + @Mock + private DeviceRepository deviceRepository; + + @Mock + private RegExceptionalHolidayRepository regExceptionalHolidayRepository; + + @Mock + private ZoneUtils zoneUtils; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.openMocks(this); + } + + @Test + public void testDeleteExpHoliday_success() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setLangCode("en_IN"); + LocalDate expHoliday = LocalDate.of(2024, 10, 02); + RegExceptionalHoliday regExceptionalHolidayEntity = new RegExceptionalHoliday(); + regExceptionalHolidayEntity.setRegistrationCenterId(registrationCenter.getId()); + regExceptionalHolidayEntity.setLangCode(registrationCenter.getLangCode()); + regExceptionalHolidayEntity.setExceptionHolidayDate(expHoliday); + + when(regExceptionalHolidayRepository.findByRegIdAndLangcodeAndExpHoliday(any(), any(), any())) + .thenReturn(regExceptionalHolidayEntity); + + ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "deleteExpHoliday", registrationCenter, expHoliday); + + verify(regExceptionalHolidayRepository).findByRegIdAndLangcodeAndExpHoliday(registrationCenter.getId(), + registrationCenter.getLangCode(), expHoliday); + verify(regExceptionalHolidayRepository).update(regExceptionalHolidayEntity); + } + + @Test + public void testDeleteExpHoliday_noRecordFound() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setLangCode("en_IN"); + LocalDate expHoliday = LocalDate.of(2024, 10, 02); + + when(regExceptionalHolidayRepository.findByRegIdAndLangcodeAndExpHoliday(any(), any(), any())) + .thenReturn(null); + + assertThrows(NullPointerException.class, ()-> ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "deleteExpHoliday", registrationCenter, expHoliday)); + + verify(regExceptionalHolidayRepository).findByRegIdAndLangcodeAndExpHoliday(registrationCenter.getId(), + registrationCenter.getLangCode(), expHoliday); + } + + @Test + public void testValidateZoneMachineDevice_sameZone() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setZoneCode("WB-KOL-E"); + RegCenterPutReqDto dto = new RegCenterPutReqDto(); + dto.setId(registrationCenter.getId()); + dto.setZoneCode(registrationCenter.getZoneCode()); + List deviceList = new ArrayList<>(); + Device device = new Device(); + device.setZoneCode("WB-KOL-E"); + deviceList.add(device); + + when(deviceRepository.findByRegIdAndIsDeletedFalseOrIsDeletedIsNull(dto.getId())).thenReturn(deviceList); + when(zoneUtils.getChildZoneList(any(), any(), any())).thenReturn(Collections.emptyList()); + + ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "validateZoneMachineDevice", registrationCenter, dto); + + verify(deviceRepository).findByRegIdAndIsDeletedFalseOrIsDeletedIsNull(dto.getId()); + verify(zoneUtils).getChildZoneList(Collections.singletonList(device.getZoneCode()), dto.getZoneCode(), dto.getLangCode()); + } + + @Test + public void testValidateZoneMachineDevice_noDevices() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setZoneCode("WB-KOL-E"); + RegCenterPutReqDto dto = new RegCenterPutReqDto(); + dto.setId(registrationCenter.getId()); + dto.setZoneCode("WB-MUM-W"); + List deviceList = Collections.emptyList(); + + lenient().when(deviceRepository.findByRegIdAndIsDeletedFalseOrIsDeletedIsNull(dto.getId())).thenReturn(deviceList); + + ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "validateZoneMachineDevice", registrationCenter, dto); + } + + @Test + public void testBuildZoneFilter_emptyZones() { + List zones = Collections.emptyList(); + List filters = ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "buildZoneFilter", zones); + assertEquals(Collections.emptyList(), filters); + } + + @Test + public void testBuildZoneFilter_nonEmptyZones() { + List zones = Arrays.asList(new Zone("WB-KOL-E", "eng", "zone1", (short) 1, "zone1Hierarchy","zone1Parent", "path/to/z1"), + new Zone("KA-BLR-S", "eng", "zone2", (short) 2, "zone2Hierarchy","zone2Parent", "path/to/z1/z2")); + List expectedFilters = Arrays.asList( + new SearchFilter("WB-KOL-E", null, null, "zoneCode", "EQUALS"), + new SearchFilter("KA-BLR-S",null, null, "zoneCode", "EQUALS")); + List filters = ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "buildZoneFilter", zones); + assertEquals(expectedFilters, filters); + } + + @Test + public void testUpdateRegistrationCenterHistory_success() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setLangCode("en_IN"); + RegistrationCenterHistory existingHistory = new RegistrationCenterHistory(); + existingHistory.setId(registrationCenter.getId()); + existingHistory.setLangCode(registrationCenter.getLangCode()); + existingHistory.setCreatedDateTime(LocalDate.of(2020,12,1).atStartOfDay()); + RegistrationCenterHistory updateData = new RegistrationCenterHistory(); + updateData.setLangCode("eng"); + + lenient().when(registrationCenterHistoryRepository.findByIdAndLangCodeAndEffectivetimesLessThanEqualAndIsDeletedFalseOrIsDeletedIsNull(registrationCenter.getId(), registrationCenter.getLangCode(), registrationCenter.getCreatedDateTime())). + thenReturn(Collections.singletonList(existingHistory)); + } + + @Test + public void testUpdateRegistrationCenterHistory_noExistingHistory() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setLangCode("en_IN"); + registrationCenter.setCreatedDateTime(LocalDate.of(2020,12,1).atStartOfDay()); + + RegistrationCenterHistory updateData = new RegistrationCenterHistory(); + updateData.setLangCode("eng"); + + lenient().when(registrationCenterHistoryRepository.findByIdAndLangCodeAndEffectivetimesLessThanEqualAndIsDeletedFalseOrIsDeletedIsNull(registrationCenter.getId(), registrationCenter.getLangCode(), registrationCenter.getCreatedDateTime())).thenReturn(null); + } + + @Test (expected = IllegalStateException.class) + public void testUpdateRegistrationCenterHistory_validationFailure() { + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId(String.valueOf(1L)); + registrationCenter.setLangCode("en_IN"); + RegistrationCenterHistory existingHistory = new RegistrationCenterHistory(); + existingHistory.setId(registrationCenter.getId()); + existingHistory.setLangCode(registrationCenter.getLangCode()); + RegistrationCenterHistory updateData = new RegistrationCenterHistory(); + updateData.setLangCode("eng"); + + lenient().when(registrationCenterHistoryRepository.findByIdAndLangCodeAndEffectivetimesLessThanEqualAndIsDeletedFalseOrIsDeletedIsNull(registrationCenter.getId(), registrationCenter.getLangCode(), registrationCenter.getCreatedDateTime())). + thenReturn(Collections.singletonList(existingHistory)); + + ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "updateRegistartionCenterHistory", registrationCenter, updateData); + } + + @Test(expected = IllegalStateException.class) + public void testUpdateRegistrationCenterHistory_missingRegistrationCenter() { + RegistrationCenter registrationCenter = null; + RegistrationCenterHistory updateData = new RegistrationCenterHistory(); + updateData.setId("123"); + + ReflectionTestUtils.invokeMethod(registrationCenterServiceImpl, "updateRegistartionCenterHistory", registrationCenter, updateData); + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/CacheNameTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/CacheNameTest.java new file mode 100644 index 00000000000..7a35f5c28fc --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/CacheNameTest.java @@ -0,0 +1,50 @@ +package io.mosip.kernel.masterdata.test.utils; + +import io.mosip.kernel.masterdata.utils.CacheName; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import static org.junit.Assert.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class CacheNameTest { + + @Test + public void testGetName() { + assertEquals("blocklisted-words", CacheName.BLOCK_LISTED_WORDS.getName()); + assertEquals("document-category", CacheName.DOCUMENT_CATEGORY.getName()); + } + + @Test + public void testCacheNameByNameValidInput() { + assertEquals(CacheName.BLOCK_LISTED_WORDS, CacheName.cacheNameByName("blocklisted-words")); + assertEquals(CacheName.DOCUMENT_CATEGORY, CacheName.cacheNameByName("document-category")); + } + + @Test + public void testCacheNameByNameInvalidInputCaseSensitivity() { + assertNull(CacheName.cacheNameByName("BLOCKLISTED-WORDS")); + } + + @Test + public void testCacheNameByNameInvalidInputNonExistentName() { + assertNull(CacheName.cacheNameByName("invalid-name")); + } + + @Test + public void testAllEnumValuesPresent() { + List expectedValues = Arrays.asList("blocklisted-words", "document-category", "document-type", "dynamic-field", "exceptional-holiday", "gender-type", "id-type", + "individual-type", "languages", "locations", "location-hierarchy", "templates", "template-type", "titles", "ui-spec", "valid-document", "working-day", "zones"); + List actualValues = Stream.of(CacheName.values()).map(CacheName::getName).toList(); + assertEquals(expectedValues.size(), actualValues.size()); + assertTrue(expectedValues.containsAll(actualValues)); + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/DeviceUtilsTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/DeviceUtilsTest.java new file mode 100644 index 00000000000..1dfd99ca5f5 --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/DeviceUtilsTest.java @@ -0,0 +1,102 @@ +package io.mosip.kernel.masterdata.test.utils; + +import io.mosip.kernel.core.dataaccess.exception.DataAccessLayerException; +import io.mosip.kernel.masterdata.entity.DeviceSpecification; +import io.mosip.kernel.masterdata.entity.DeviceType; +import io.mosip.kernel.masterdata.entity.RegistrationCenter; +import io.mosip.kernel.masterdata.exception.MasterDataServiceException; +import io.mosip.kernel.masterdata.repository.DeviceSpecificationRepository; +import io.mosip.kernel.masterdata.repository.DeviceTypeRepository; +import io.mosip.kernel.masterdata.repository.RegistrationCenterRepository; +import io.mosip.kernel.masterdata.utils.DeviceUtils; +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.boot.test.context.SpringBootTest; + +import java.util.List; + +import static org.junit.Assert.assertEquals; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class DeviceUtilsTest { + + @Mock + private DeviceSpecificationRepository deviceSpecificationRepository; + + @Mock + private DeviceTypeRepository deviceTypeRepository; + + @Mock + private RegistrationCenterRepository centerRepository; + + @InjectMocks + private DeviceUtils deviceUtils; + + @Test + public void testGetDeviceSpec_Success() { + List mockDeviceSpecs = List.of(new DeviceSpecification()); + + Mockito.when(deviceSpecificationRepository.findAllDeviceSpecByIsActiveAndIsDeletedIsNullOrFalse()) + .thenReturn(mockDeviceSpecs); + + List deviceSpecs = deviceUtils.getDeviceSpec(); + + assertEquals(mockDeviceSpecs, deviceSpecs); + } + + @Test(expected = MasterDataServiceException.class) + public void testGetDeviceSpec_DataAccessLayerException() { + Mockito.when(deviceSpecificationRepository.findAllDeviceSpecByIsActiveAndIsDeletedIsNullOrFalse()) + .thenThrow(DataAccessLayerException.class); + + deviceUtils.getDeviceSpec(); + } + + @Test + public void testGetDeviceTypes_Success() { + List mockDeviceTypes = List.of(new DeviceType()); + + Mockito.when(deviceTypeRepository.findAllDeviceTypeByIsActiveAndIsDeletedFalseOrNull()) + .thenReturn(mockDeviceTypes); + + List deviceTypes = deviceUtils.getDeviceTypes(); + + assertEquals(mockDeviceTypes, deviceTypes); + } + + @Test(expected = MasterDataServiceException.class) + public void testGetDeviceTypes_DataAccessLayerException() { + Mockito.when(deviceTypeRepository.findAllDeviceTypeByIsActiveAndIsDeletedFalseOrNull()) + .thenThrow(DataAccessLayerException.class); + + deviceUtils.getDeviceTypes(); + } + + @Test + public void testGetAllRegistrationCenters_Success() { + String langCode = "en_US"; + List mockCenters = List.of(new RegistrationCenter()); + + Mockito.when(centerRepository.findAllByIsDeletedFalseOrIsDeletedIsNullAndLangCode(langCode)) + .thenReturn(mockCenters); + + List centers = deviceUtils.getAllRegistrationCenters(langCode); + + assertEquals(mockCenters, centers); + } + + @Test(expected = MasterDataServiceException.class) + public void testGetAllRegistrationCenters_DataAccessLayerException() { + String langCode = "en_US"; + + Mockito.when(centerRepository.findAllByIsDeletedFalseOrIsDeletedIsNullAndLangCode(langCode)) + .thenThrow(DataAccessLayerException.class); + + deviceUtils.getAllRegistrationCenters(langCode); + } +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/FieldComparatorTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/FieldComparatorTest.java new file mode 100644 index 00000000000..7baa4e50086 --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/FieldComparatorTest.java @@ -0,0 +1,170 @@ +package io.mosip.kernel.masterdata.test.utils; + +import io.mosip.kernel.masterdata.dto.request.SearchSort; +import io.mosip.kernel.masterdata.utils.FieldComparator; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; + +import java.lang.reflect.Field; +import java.time.LocalDate; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class FieldComparatorTest { + + private static final String NAME_FIELD = "name"; + private static final String AGE_FIELD = "age"; + private static final String DOB_FIELD = "dob"; + + @Test + public void testCompare_String_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort(NAME_FIELD, "ASC")); + TestObject obj1 = new TestObject("Alice"); + TestObject obj2 = new TestObject("Bob"); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(-1, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort(NAME_FIELD, "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + } + + @Test + public void testCompare_Integer_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, AGE_FIELD), new SearchSort(AGE_FIELD, "ASC")); + TestObject obj1 = new TestObject(25); + TestObject obj2 = new TestObject(30); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(-1, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, AGE_FIELD), new SearchSort(AGE_FIELD, "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + } + + @Test + public void testCompare_Boolean_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("isActive", "ASC")); + TestObject obj1 = new TestObject(String.valueOf(true)); + TestObject obj2 = new TestObject(String.valueOf(false)); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(14, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("isActive", "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(-14, result); + } + + @Test + public void testCompare_Double_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("salary", "ASC")); + TestObject obj1 = new TestObject(String.valueOf(2500.50)); + TestObject obj2 = new TestObject(String.valueOf(3000.75)); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(-1, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("salary", "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + } + + @Test + public void testCompare_Long_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, AGE_FIELD), new SearchSort("id", "ASC")); + TestObject obj1 = new TestObject(String.valueOf(123456L)); + TestObject obj2 = new TestObject(String.valueOf(987654L)); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(0, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, AGE_FIELD), new SearchSort("id", "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(0, result); + } + + @Test + public void testCompare_Float_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("percentage", "ASC")); + TestObject obj1 = new TestObject(String.valueOf(3.14f)); + TestObject obj2 = new TestObject(String.valueOf(2.72f)); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, NAME_FIELD), new SearchSort("percentage", "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(-1, result); + } + + @Test + public void testCompare_LocalDate_Ascending() throws Exception { + FieldComparator comparator = new FieldComparator<>(getDeclaredField(TestObject.class, DOB_FIELD), new SearchSort(DOB_FIELD, "ASC")); + TestObject obj1 = new TestObject(LocalDate.of(2000, 1, 1)); + TestObject obj2 = new TestObject(LocalDate.of(2001, 1, 1)); + + int result = comparator.compare(obj1, obj2); + Assert.assertEquals(-1, result); + + comparator = new FieldComparator<>(getDeclaredField(TestObject.class, DOB_FIELD), new SearchSort(DOB_FIELD, "DESC")); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + + obj1.setDob(null); + result = comparator.compare(obj1, obj2); + Assert.assertEquals(1, result); + } + + private Field getDeclaredField(Class clazz, String fieldName) throws NoSuchFieldException { + return clazz.getDeclaredField(fieldName); + } + + class TestObject { + private String name; + private int age; + private LocalDate dob; + + public TestObject(String name) { + this.name = name; + } + + public TestObject(int age) { + this.age = age; + } + + public TestObject(LocalDate dob) { + this.dob = dob; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public LocalDate getDob() { + return dob; + } + + public void setDob(LocalDate dob) { + this.dob = dob; + } + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RegistrationCenterValidatorTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RegistrationCenterValidatorTest.java new file mode 100644 index 00000000000..4ddeb674bcc --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RegistrationCenterValidatorTest.java @@ -0,0 +1,63 @@ +package io.mosip.kernel.masterdata.test.utils; + +import io.mosip.kernel.masterdata.dto.RegCenterPutReqDto; +import io.mosip.kernel.masterdata.entity.RegistrationCenter; +import io.mosip.kernel.masterdata.utils.RegistrationCenterValidator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; + +import java.time.LocalTime; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class RegistrationCenterValidatorTest { + + @Mock + RegistrationCenterValidator registrationCenterValidator; + + @Test + public void testRegCenterPutReqDto_ValidData() { + + RegistrationCenter registrationCenter = new RegistrationCenter(); + registrationCenter.setId("regCenterId"); + registrationCenter.setName("Center Name"); + registrationCenter.setLangCode("eng"); + + List newregistrationCenterList = new ArrayList<>(); + newregistrationCenterList.add(registrationCenter); + + RegCenterPutReqDto reqDto = new RegCenterPutReqDto(); + reqDto.setId("regCenterId"); + reqDto.setName("Center124"); + reqDto.setAddressLine1("Address Line 1"); + reqDto.setAddressLine2("Address Line 2"); + reqDto.setLangCode("eng"); + reqDto.setNumberOfKiosks((short) 5); + reqDto.setContactPerson("John Doe"); + reqDto.setCenterTypeCode("centerTypeCode"); + reqDto.setLatitude("12.3456"); + reqDto.setLongitude("78.9012"); + reqDto.setLocationCode("locCode123"); + reqDto.setHolidayLocationCode("holidayLocCode"); + reqDto.setContactPhone("1234567890"); + reqDto.setWorkingHours("09:00:00-17:00:00"); + reqDto.setPerKioskProcessTime(LocalTime.of(0, 15, 0)); + reqDto.setCenterStartTime(LocalTime.of(8, 0, 0)); + reqDto.setCenterEndTime(LocalTime.of(18, 0, 0)); + reqDto.setLunchStartTime(LocalTime.of(12, 30, 0)); + reqDto.setLunchEndTime(LocalTime.of(13, 30, 0)); + reqDto.setTimeZone("Asia/Kolkata"); + reqDto.setZoneCode("zoneCode123"); + reqDto.setWorkingNonWorkingDays(Collections.singletonMap("MONDAY", true)); + reqDto.setExceptionalHolidayPutPostDto(Collections.emptyList()); + + registrationCenterValidator.createRegCenterPut(newregistrationCenterList, registrationCenter, reqDto); + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RestClientTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RestClientTest.java new file mode 100644 index 00000000000..e43ee448146 --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/utils/RestClientTest.java @@ -0,0 +1,192 @@ +package io.mosip.kernel.masterdata.test.utils; + +import io.mosip.kernel.masterdata.constant.ApiName; +import io.mosip.kernel.masterdata.utils.RestClient; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.core.env.Environment; +import org.springframework.http.*; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.web.client.RestTemplate; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +@SpringBootTest +@ContextConfiguration(classes = {RestClient.class}) +@RunWith(SpringRunner.class) +public class RestClientTest { + + @MockBean + private Environment environment; + + @Autowired + private RestClient restClient; + + @MockBean + private RestTemplate restTemplate; + + + @Test + public void postApi_withValidInput_thenSuccess() throws Exception { + + ApiName apiName = ApiName.PACKET_PAUSE_API; + List pathsegments =List.of("hi","hello","welcome"); + String queryParamName = "name"; + String queryParamValue = "value"; + MediaType mediaType = mock(MediaType.class); + Object requestType = mock(Object.class); + Class responseType = Class.class; + + restClient.postApi(apiName,pathsegments,queryParamName,queryParamValue,mediaType,requestType,responseType); + assertNotNull(requestType); + } + + @Test + public void postApi_withProperty_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", + "42", null, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + + @Test + public void postApi_withPacketResumeApi_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + + ArrayList stringList = new ArrayList<>(); + stringList.add("RestClientTest"); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, stringList, "Query Param Name", + "42", null, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void getApi_withValidInput_thenSuccess() throws Exception { + ApiName apiName = ApiName.PACKET_PAUSE_API; + List pathsegments = List.of("hi","hello","welcome"); + String queryParamName = "name"; + String queryParamValue = "value"; + Class responseType = Class.class; + + restClient.getApi(apiName,pathsegments,queryParamName,queryParamValue,responseType); + assertNotNull(pathsegments); + } + + @Test + public void getApi_withProperty_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.exchange(any(), any(), any(), (Class) any())) + .thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + ArrayList pathsegments = new ArrayList<>(); + + assertNull(restClient.getApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", "42", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).exchange(any(), any(), any(), (Class) any()); + } + + @Test + public void getApi_withoutPathsegments_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.exchange(any(), any(), any(), (Class) any())) + .thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + + ArrayList stringList = new ArrayList<>(); + stringList.add("RestClientTest"); + + assertNull(restClient.getApi(ApiName.PACKET_RESUME_API, stringList, "Query Param Name", "42", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).exchange(any(), any(), any(), (Class) any()); + } + + @Test (expected = Exception.class) + public void getApi_withInvalidProperty_returnErrorResponse() throws Exception { + when(environment.getProperty(any())).thenReturn("dev@1:2:3{Mosip}"); + when(restTemplate.exchange(any(), any(), any(), (Class) any())) + .thenReturn(new ResponseEntity<>(HttpStatus.CONTINUE)); + ArrayList pathsegments = new ArrayList<>(); + restClient.getApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", "42", Object.class); + verify(environment).getProperty(any()); + } + + @Test + public void setRequestHeader_withProperty_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + MediaType mediaType = mock(MediaType.class); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", + "42", mediaType, "Request Type", Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void setRequestHeader_withRequestType_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + HttpEntity requestType = new HttpEntity<>(new HttpHeaders()); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", + "42", null, requestType, Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + @Test + public void setRequestHeader_withPathsegments_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", + "42", null, null, Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + } + + + @Test + public void setRequestHeader_withHttpURL_thenSuccess() throws Exception { + when(environment.getProperty(any())).thenReturn("Property"); + when(restTemplate.postForObject(any(), any(), any(), (Object[]) any())) + .thenReturn("Post For Object"); + ArrayList pathsegments = new ArrayList<>(); + + HttpHeaders httpHeaders = new HttpHeaders(); + httpHeaders.add("https://dev.mosip.net/", "https://dev.mosip.net/"); + HttpEntity httpEntity = mock(HttpEntity.class); + when(httpEntity.getBody()).thenThrow(new ClassCastException()); + when(httpEntity.getHeaders()).thenReturn(httpHeaders); + + assertEquals("Post For Object", restClient.postApi(ApiName.PACKET_RESUME_API, pathsegments, "Query Param Name", + "42", null, httpEntity, Object.class)); + verify(environment).getProperty(any()); + verify(restTemplate).postForObject(any(), any(), any(), (Object[]) any()); + verify(httpEntity).getBody(); + verify(httpEntity).getHeaders(); + } + +} \ No newline at end of file diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FieldValidatorTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FieldValidatorTest.java new file mode 100644 index 00000000000..7b8379d103a --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FieldValidatorTest.java @@ -0,0 +1,87 @@ +package io.mosip.kernel.masterdata.test.validator; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.mosip.kernel.masterdata.validator.FieldValidator; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; + +import static org.junit.Assert.assertFalse; +import static org.mockito.Mockito.when; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class FieldValidatorTest { + + @Mock + private JsonNode jsonNode; + + private FieldValidator validator; + private ObjectMapper mapper; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + validator = new FieldValidator(); + mapper = new ObjectMapper(); + } + + @Test + public void testIsValidValidInput() { + validator.setAllowedCodeCharactersRegex("[a-zA-Z0-9_]"); + validator.setAllowedValueCharactersRegex("[a-zA-Z0-9.,!@#$%^&*()]"); + validator.initialize(null); + + when(jsonNode.get("value")).thenReturn(mapper.valueToTree("valid_value")); + when(jsonNode.get("code")).thenReturn(mapper.valueToTree("valid_code")); + + assertFalse(validator.isValid(jsonNode, null)); + } + + @Test + public void testIsValidEmptyValueOrCode() { + validator.setAllowedCodeCharactersRegex("[a-zA-Z0-9_]"); + validator.setAllowedValueCharactersRegex("[a-zA-Z0-9.,!@#$%^&*()]"); + validator.initialize(null); + + when(jsonNode.get("value")).thenReturn(mapper.valueToTree("")); + when(jsonNode.get("code")).thenReturn(mapper.valueToTree("valid_code")); + + assertFalse(validator.isValid(jsonNode, null)); + + when(jsonNode.get("value")).thenReturn(mapper.valueToTree("valid_value")); + when(jsonNode.get("code")).thenReturn(mapper.valueToTree("")); + + assertFalse(validator.isValid(jsonNode, null)); + } + + @Test + public void testIsValidInvalidCharactersCode() { + validator.setAllowedCodeCharactersRegex("[a-zA-Z0-9_]"); + validator.setAllowedValueCharactersRegex("[a-zA-Z0-9.,!@#$%^&*()]"); + validator.initialize(null); + + when(jsonNode.get("value")).thenReturn(mapper.valueToTree("valid_value")); + when(jsonNode.get("code")).thenReturn(mapper.valueToTree("invalid code!")); + + assertFalse(validator.isValid(jsonNode, null)); + } + + @Test + public void testIsValidInvalidCharactersValue() { + validator.setAllowedCodeCharactersRegex("[a-zA-Z0-9_]"); + validator.setAllowedValueCharactersRegex("[a-zA-Z0-9.,!@#$%^&*()]"); + validator.initialize(null); + + when(jsonNode.get("value")).thenReturn(mapper.valueToTree("invalid value@")); + when(jsonNode.get("code")).thenReturn(mapper.valueToTree("valid_code")); + + assertFalse(validator.isValid(jsonNode, null)); + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FoundationalValidatorTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FoundationalValidatorTest.java new file mode 100644 index 00000000000..7e2586db5ff --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/FoundationalValidatorTest.java @@ -0,0 +1,125 @@ +package io.mosip.kernel.masterdata.test.validator; + +import io.mosip.kernel.masterdata.dto.registerdevice.DeviceData; +import io.mosip.kernel.masterdata.dto.registerdevice.DeviceInfo; +import io.mosip.kernel.masterdata.validator.registereddevice.FoundationalValidator; +import io.mosip.kernel.masterdata.validator.registereddevice.RegisteredDeviceConstant; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.web.client.RestClientException; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class FoundationalValidatorTest { + + @Test + public void testValidL1Certification() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification(RegisteredDeviceConstant.L1); + deviceData.setDeviceInfo(deviceInfo); + deviceData.setFoundationalTrustProviderId("valid_provider_id"); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertTrue(isValid); + } + + @Test + public void testMissingFoundationalTrustProviderIdForL1() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification(RegisteredDeviceConstant.L1); + deviceData.setDeviceInfo(deviceInfo); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertFalse(isValid); + } + + @Test + public void testValidL0Certification() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification(RegisteredDeviceConstant.L0); + deviceData.setDeviceInfo(deviceInfo); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertFalse(isValid); + } + + @Test + public void testMissingDeviceInfo() { + DeviceData deviceData = new DeviceData(); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertFalse(isValid); + } + + @Test + public void testMissingCertificationInDeviceInfo() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceData.setDeviceInfo(deviceInfo); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertFalse(isValid); + } + + @Test(expected = RestClientException.class) + public void testRestClientException() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification(RegisteredDeviceConstant.L1); + deviceData.setDeviceInfo(deviceInfo); + deviceData.setFoundationalTrustProviderId("valid_provider_id"); + + FoundationalValidator validator = Mockito.mock(FoundationalValidator.class); + Mockito.when(validator.isValid(deviceData, null)).thenThrow(new RestClientException("Rest Client Exception")); + + validator.isValid(deviceData, null); + } + + @Test + public void testUnknownCertification() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification("UNKNOWN"); + deviceData.setDeviceInfo(deviceInfo); + deviceData.setFoundationalTrustProviderId("valid_provider_id"); + + FoundationalValidator validator = new FoundationalValidator(); + boolean isValid = validator.isValid(deviceData, null); + + assertTrue(isValid); + } + + @Test + public void testEmptyTrustProviderIdWithMock() { + DeviceData deviceData = new DeviceData(); + DeviceInfo deviceInfo = new DeviceInfo(); + deviceInfo.setCertification(null); + deviceData.setDeviceInfo(deviceInfo); + + FoundationalValidator validator = new FoundationalValidator(); + + boolean isValid = validator.isValid(deviceData, null); + + assertFalse(isValid); + } + +} diff --git a/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/TypeValidatorTest.java b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/TypeValidatorTest.java new file mode 100644 index 00000000000..adba66fbe3d --- /dev/null +++ b/admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/TypeValidatorTest.java @@ -0,0 +1,57 @@ +package io.mosip.kernel.masterdata.test.validator; + +import io.mosip.kernel.masterdata.exception.RequestException; +import io.mosip.kernel.masterdata.validator.registereddevice.TypeValidator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.web.client.RestClientException; + +import static org.junit.Assert.assertFalse; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class TypeValidatorTest { + + @Test + public void testIsValid_EmptyType() { + TypeValidator validator = new TypeValidator(); + String emptyType = ""; + + boolean isValid = validator.isValid(emptyType, null); + + assertFalse(isValid); + } + + @Test + public void testIsValid_NullType() { + TypeValidator validator = new TypeValidator(); + + boolean isValid = validator.isValid(null, null); + + assertFalse(isValid); + } + + @Test + public void testIsValid_InvalidType() { + TypeValidator validator = new TypeValidator(); + String invalidType = "INVALID_TYPE"; + + boolean isValid = validator.isValid(invalidType, null); + + assertFalse(isValid); + } + + @Test(expected = RestClientException.class) + public void testIsValid_RestClientException() throws RequestException { + TypeValidator validator = mock(TypeValidator.class); + String type = "anyType"; + when(validator.isValid(type, null)).thenThrow(new RestClientException("RestClientException")); + + validator.isValid(type, null); + } + +} diff --git a/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncConfigDetailsServiceImplTest.java b/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncConfigDetailsServiceImplTest.java new file mode 100644 index 00000000000..dddbd67dcfd --- /dev/null +++ b/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncConfigDetailsServiceImplTest.java @@ -0,0 +1,285 @@ +package io.mosip.kernel.syncdata.test.service; + +import io.mosip.kernel.syncdata.dto.PublicKeyResponse; +import io.mosip.kernel.syncdata.entity.Machine; +import io.mosip.kernel.syncdata.exception.RequestException; +import io.mosip.kernel.syncdata.exception.SyncDataServiceException; +import io.mosip.kernel.syncdata.repository.MachineRepository; +import io.mosip.kernel.syncdata.service.impl.SyncConfigDetailsServiceImpl; +import io.mosip.kernel.syncdata.utils.MapperUtils; +import net.minidev.json.JSONObject; +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.beans.factory.annotation.Value; +import org.springframework.core.env.Environment; +import org.springframework.http.HttpStatus; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.client.MockRestServiceServer; +import org.springframework.test.web.client.match.MockRestRequestMatchers; +import org.springframework.web.client.HttpClientErrorException; +import org.springframework.web.client.RestClientException; +import org.springframework.web.client.RestTemplate; +import org.springframework.web.util.UriComponentsBuilder; + +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.lenient; +import static org.springframework.test.web.client.response.MockRestResponseCreators.withServerError; +import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess; + +@RunWith(MockitoJUnitRunner.class) +public class SyncConfigDetailsServiceImplTest { + + @InjectMocks + private SyncConfigDetailsServiceImpl syncConfigDetailsService; + + @Mock + private MachineRepository machineRepository; + + @Mock + private RestTemplate restTemplate; + + @Mock + private Environment environment; + + @Mock + private MapperUtils mapper; + + Map uriParams = null; + + @Value("${mosip.kernel.keymanager-service-publickey-url}") + private String publicKeyUrl; + + + @Test + public void getConfigDetails_success() { + String keyIndex = "test-machine"; + List machines = new ArrayList<>(); + Machine machine = new Machine(); + machine.setPublicKey("MIGfMA0GCSqGSIb3DQEBAQUAA4GNAD..."); + machines.add(machine); + + lenient().when(machineRepository.findByMachineKeyIndex(keyIndex)).thenReturn(machines); + } + + @Test(expected = RequestException.class) + public void getConfigDetails_machineNotFound() { + String keyIndex = "not-found-machine"; + lenient().when(machineRepository.findByMachineKeyIndex(keyIndex)).thenReturn(Collections.emptyList()); + + syncConfigDetailsService.getConfigDetails(keyIndex); + } + + @Test(expected = Exception.class) + public void getPublicKey_clientException() { + String applicationId = "mosip-kernel"; + String timeStamp = "2024-06-17T16:29:00Z"; + String referenceId = "ref-id"; + + lenient().when(restTemplate.getForEntity(any(), any())).thenThrow(new HttpClientErrorException(HttpStatus.BAD_REQUEST)); + + syncConfigDetailsService.getPublicKey(applicationId, timeStamp, referenceId); + } + + @Test + public void getScript_success() { + String scriptName = "applicanttype.mvel"; + String keyIndex = "test-machine"; + List machines = new ArrayList<>(); + Machine machine = new Machine(); + machine.setPublicKey("MIGfMA0GCSqGSIb3DQEBAQUAA4GNAD..."); + machines.add(machine); + + lenient().when(machineRepository.findByMachineKeyIndex(keyIndex)).thenReturn(machines); + lenient().when(environment.getProperty(String.format("mosip.sync.entity.encrypted.%s", scriptName.toUpperCase()), Boolean.class, false)).thenReturn(false); + } + + @Test(expected = RequestException.class) + public void getScript_machineNotFound() throws Exception { + String scriptName = "applicanttype.mvel"; + String keyIndex = "not-found-machine"; + lenient().when(machineRepository.findByMachineKeyIndex(keyIndex)).thenReturn(Collections.emptyList()); + + syncConfigDetailsService.getScript(scriptName, keyIndex); + } + + @Test + public void parsePropertiesString_emptyString() { + String input = ""; + JSONObject expectedOutput = new JSONObject(); + JSONObject actualOutput = new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + assertEquals(expectedOutput, actualOutput); + } + + @Test + public void parsePropertiesString_singleKeyValue() { + String input = "name=John Doe"; + JSONObject expectedOutput = new JSONObject(); + expectedOutput.put("name", "John Doe"); + JSONObject actualOutput = new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + assertEquals(expectedOutput, actualOutput); + } + + @Test + public void parsePropertiesString_multipleKeyValues() { + String input = "name=John Doe\nage=30\ncity=New York"; + JSONObject expectedOutput = new JSONObject(); + expectedOutput.put("name", "John Doe"); + expectedOutput.put("age", "30"); + expectedOutput.put("city", "New York"); + JSONObject actualOutput = new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + assertEquals(expectedOutput, actualOutput); + } + + @Test + public void parsePropertiesString_emptyValue() { + String input = "city=New York"; + JSONObject expectedOutput = new JSONObject(); + expectedOutput.put("city", "New York"); + JSONObject actualOutput = new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + assertEquals(expectedOutput, actualOutput); + } + + @Test + public void parsePropertiesString_comments() { + String input = "# This is a comment\nname=John Doe\nage=30\n# Another comment"; + JSONObject expectedOutput = new JSONObject(); + expectedOutput.put("name", "John Doe"); + expectedOutput.put("age", "30"); + JSONObject actualOutput = new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + assertEquals(expectedOutput, actualOutput); + } + + @Test + public void parsePropertiesString_invalidFormat() { + String input = "invalid format"; + new SyncConfigDetailsServiceImpl().parsePropertiesString(input); + } + + @Test + public void getPublicKey() { + + try { + uriParams = new HashMap<>(); + uriParams.put("applicationId", "REGISTRATION"); + + UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(publicKeyUrl) + .queryParam("referenceId", "referenceId").queryParam("timeStamp", "2019-09-09T09:00:00.000Z"); + MockRestServiceServer mockRestServer = MockRestServiceServer.bindTo(restTemplate).build(); + + mockRestServer.expect(MockRestRequestMatchers.requestTo(builder.buildAndExpand(uriParams).toString())) + .andRespond(withSuccess().body( + "{ \"id\": null, \"version\": null, \"responsetime\": \"2019-04-24T09:07:42.017Z\", \"metadata\": null, \"response\": { \"lastSyncTime\": \"2019-04-24T09:07:41.771Z\", \"publicKey\": \"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtzi3nWiNMEcaBV2cWO5ZLTBZe1TEGnT95bTvrpEEr-kJLrn80dn9k156zjQpjSzNfEOFVwugTEhEWdxrdrjDUACpA0cF4tUdAM5XJBB0xmzNGS5s7lmcliAOjXbCGU2VJwOUnYV4DSCgrReMCCe6LD_aApwu45OAZ9_sWG6R-jlIUOHLTdDUs6O8zLk8zl7tOX6Rlp25Zk9CLQw1m9drHJqxCbr9Wc9PQKUHBPqhtvCe9ZZeySsZb83dXpKKAZlkjdbrB25i_4O0pbv9LHk0qQlk0twqaef6D5nCTqcB5KQ4QqVYLcrtAhdbMXaDvpSf9syRQ3P3fAeiGkvUIhUWPwIDAQAB\", \"issuedAt\": \"2019-04-23T06:17:46.753\", \"expiryAt\": \"2020-04-23T06:17:46.753\" }, \"errors\": null }")); + + PublicKeyResponse publicKeyResponse = syncConfigDetailsService.getPublicKey("REGISTRATION", "2019-09-09T09:00:00.000Z", "referenceId"); + + assertNotNull(publicKeyResponse.getProfile()); + assertEquals("test", publicKeyResponse.getProfile()); + } catch (Exception ex){ + ex.getCause(); + } + } + + @Test + public void getPublicKeyServiceExceptionTest() { + + try { + uriParams = new HashMap<>(); + uriParams.put("applicationId", "REGISTRATION"); + + UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(publicKeyUrl) + .queryParam("referenceId", "referenceId").queryParam("timeStamp", "2019-09-09T09:00:00.000Z"); + MockRestServiceServer mockRestServer = MockRestServiceServer.bindTo(restTemplate).build(); + + mockRestServer.expect(MockRestRequestMatchers.requestTo(builder.buildAndExpand(uriParams).toString())) + .andRespond(withServerError()); + + syncConfigDetailsService.getPublicKey("REGISTRATION", "2019-09-09T09:00:00.000Z", "referenceId"); + } catch (Exception e){ + e.getCause(); + } + } + + @Test (expected = SyncDataServiceException.class) + public void getEncryptedData_success() { + JSONObject config = new JSONObject(); + config.put("key", "value"); + Machine machine = new Machine(); + machine.setPublicKey("MIGfMA0GCSqGSIb3DQEBAQUAA4GNAD..."); + + String expectedJsonString = "{\"key\":\"value\"}"; + ReflectionTestUtils.invokeMethod(mapper,"getObjectAsJsonString", config); + + String encryptedData = "encrypted_data"; + ReflectionTestUtils.invokeMethod(syncConfigDetailsService, "getEncryptedData", expectedJsonString, machine); + + String actualEncryptedData = ReflectionTestUtils.invokeMethod(syncConfigDetailsService,"getEncryptedData",config, machine); + + assertEquals(encryptedData, actualEncryptedData); + } + + @Test(expected = SyncDataServiceException.class) + public void getEncryptedData_serializationError() throws Exception { + JSONObject config = new JSONObject(); + config.put("key", "value"); + Machine machine = new Machine(); + machine.setPublicKey("MIGfMA0GCSqGSIb3DQEBAQUAA4GNAD..."); + + Mockito.when(mapper.getObjectAsJsonString(config)).thenThrow(new RuntimeException("Serialization error")); + + ReflectionTestUtils.invokeMethod(syncConfigDetailsService, "getEncryptedData",config, machine); + } + + @Test + public void getConfigDetailsResponse_success() { + String fileName = "application.yml"; + String expectedUri = "http://localhost:8888/my-app/dev/my-label/" + fileName; + String responseBody = "config content"; + + Mockito.when(environment.getProperty("spring.cloud.config.uri")).thenReturn("http://localhost:8888"); + Mockito.when(environment.getProperty("spring.application.name")).thenReturn("my-app"); + Mockito.when(environment.getProperty("spring.profiles.active")).thenReturn("dev"); + Mockito.when(environment.getProperty("spring.cloud.config.label")).thenReturn("my-label"); + Mockito.when(restTemplate.getForObject(expectedUri, String.class)).thenReturn(responseBody); + + String actualResponse = ReflectionTestUtils.invokeMethod(syncConfigDetailsService, "getConfigDetailsResponse", fileName); + + assertEquals(responseBody, actualResponse); + } + + @Test(expected = SyncDataServiceException.class) + public void getConfigDetailsResponse_nullResponse() { + String fileName = "application.yml"; + String expectedUri = "http://localhost:8888/my-app/dev/my-label/" + fileName; + + Mockito.when(environment.getProperty("spring.cloud.config.uri")).thenReturn("http://localhost:8888"); + Mockito.when(environment.getProperty("spring.application.name")).thenReturn("my-app"); + Mockito.when(environment.getProperty("spring.profiles.active")).thenReturn("dev"); + Mockito.when(environment.getProperty("spring.cloud.config.label")).thenReturn("my-label"); + Mockito.when(restTemplate.getForObject(expectedUri, String.class)).thenReturn(null); + + ReflectionTestUtils.invokeMethod(syncConfigDetailsService, "getConfigDetailsResponse", fileName); + } + + @Test(expected = SyncDataServiceException.class) + public void getConfigDetailsResponse_restClientException() { + String fileName = "application.yml"; + String expectedUri = "http://localhost:8888/my-app/dev/my-label/" + fileName; + + Mockito.when(environment.getProperty("spring.cloud.config.uri")).thenReturn("http://localhost:8888"); + Mockito.when(environment.getProperty("spring.application.name")).thenReturn("my-app"); + Mockito.when(environment.getProperty("spring.profiles.active")).thenReturn("dev"); + Mockito.when(environment.getProperty("spring.cloud.config.label")).thenReturn("my-label"); + Mockito.when(restTemplate.getForObject(expectedUri, String.class)).thenThrow(new RestClientException("Connection refused")); + + ReflectionTestUtils.invokeMethod(syncConfigDetailsService, "getConfigDetailsResponse", fileName); + } + +} diff --git a/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncJobHelperServiceTest.java b/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncJobHelperServiceTest.java new file mode 100644 index 00000000000..f67113a4908 --- /dev/null +++ b/admin/kernel-syncdata-service/src/test/java/io/mosip/kernel/syncdata/test/service/SyncJobHelperServiceTest.java @@ -0,0 +1,170 @@ +package io.mosip.kernel.syncdata.test.service; + +import io.mosip.kernel.syncdata.dto.BlacklistedWordsDto; +import io.mosip.kernel.syncdata.dto.DynamicFieldDto; +import io.mosip.kernel.syncdata.entity.*; +import io.mosip.kernel.syncdata.service.helper.SyncJobHelperService; +import io.mosip.kernel.syncdata.utils.MapperUtils; +import io.mosip.kernel.syncdata.utils.SyncMasterDataServiceHelper; +import org.junit.Assert; +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.cache.Cache; +import org.springframework.cache.CacheManager; +import org.springframework.web.client.RestTemplate; + +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +import static org.mockito.Mockito.*; + +@SpringBootTest +@RunWith(MockitoJUnitRunner.class) +public class SyncJobHelperServiceTest { + + @Mock + private SyncMasterDataServiceHelper serviceHelper; + + @Mock + private MapperUtils mapper; + + @Mock + private CacheManager cacheManager; + + @InjectMocks + private SyncJobHelperService syncJobHelperService; + + @Test + public void testEvictDeltaCaches() { + Cache cache = mock(Cache.class); + lenient().when(cacheManager.getCache("delta-sync")).thenReturn(cache); + + syncJobHelperService.evictDeltaCaches(); + + verify(cache).clear(); + } + + @Test + public void testGetFullSyncCurrentTimestamp() { + LocalDateTime localDateTime = LocalDateTime.now(ZoneOffset.UTC); + LocalDateTime expectedTimestamp = localDateTime.withHour(0).withMinute(0).withSecond(0).withNano(0); + + LocalDateTime actualTimestamp = syncJobHelperService.getFullSyncCurrentTimestamp(); + + Assert.assertEquals(expectedTimestamp, actualTimestamp); + } + + @Test + public void testGetDeltaSyncCurrentTimestamp() { + lenient().when(serviceHelper.getAppAuthenticationMethodDetails(any(), any(LocalDateTime.class))).thenReturn(CompletableFuture.completedFuture(new ArrayList<>())); + } + + @Test + public void testClearCacheAndRecreateSnapshot_Success() throws Exception { + List appAuthMethods = new ArrayList<>(); + List appRolePriorities = new ArrayList<>(); + List