MOSIP-32453 : Increasing the code coverage for admin service

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<Object> 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<Object> 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<Object> 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<Object> 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<Object> 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);
+
+    }
+
+}

admin/admin-service/src/test/java/io/mosip/admin/bulkdataupload/batch/RepositoryListItemWriterTest.java

@@ -0,0 +1,193 @@
+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.*;
+import static org.mockito.Mockito.*;
+
+@SpringBootTest
+@RunWith(MockitoJUnitRunner.class)
+public class RepositoryListItemWriterTest {
+
+    @InjectMocks
+    private RepositoryListItemWriter<T> 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<T> emptyChunk = new Chunk<>(new ArrayList<>());
+        writer.write(emptyChunk);
+
+        assertEquals(0, emptyChunk.getItems().size());
+        assertEquals(0, emptyChunk.getSkips().size());
+    }
+
+    @Test
+    public void testWrite_InsertSuccess() {
+        List<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        entities.add(entity2);
+
+        assertNotNull(entities);
+
+        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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        Chunk<T> chunk = new Chunk<>(entities);
+
+        assertNotNull(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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+
+        assertNotNull(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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        Chunk<T> 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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+
+        assertNotNull(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(entity1);
+    }
+
+    @Test
+    public void testWrite_DeleteNotFound() {
+        List<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        Chunk<T> 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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        Chunk<T> 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<T> entities = new ArrayList<>();
+        entities.add(entity1);
+        Chunk<T> 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));
+    }
+
+}