MOSIP-42804 - increasing the code coverage

admin/admin-service/src/test/java/io/mosip/admin/validator/LanguageCharacterValidatorTest.java

@@ -0,0 +1,79 @@
+package io.mosip.admin.validator;
+
+import jakarta.validation.ConstraintValidatorContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import static org.junit.Assert.*;
+
+public class LanguageCharacterValidatorTest {
+
+    private LanguageCharacterValidator validator;
+
+    @Before
+    public void setUp() {
+        validator = new LanguageCharacterValidator();
+    }
+
+    @Test
+    public void isValidShouldReturnTrueWhenAllowedCharactersRegexIsNull() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", null);
+        // when
+        boolean result = validator.isValid("AnyValue123", (ConstraintValidatorContext) null);
+        // then
+        assertTrue(result);
+    }
+
+    @Test
+    public void isValidShouldReturnTrueWhenValueIsNull() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", "[^a-zA-Z]");
+        // when
+        boolean result = validator.isValid(null, (ConstraintValidatorContext) null);
+        // then
+        assertTrue(result);
+    }
+
+    @Test
+    public void isValidShouldReturnTrueWhenValueIsEmpty() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", "[^a-zA-Z]");
+        // when
+        boolean result = validator.isValid("", (ConstraintValidatorContext) null);
+        // then
+        assertTrue(result);
+    }
+
+    @Test
+    public void isValidShouldReturnTrueWhenValueContainsOnlyAllowedCharacters() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", "[^a-zA-Z]");
+        // when
+        boolean result = validator.isValid("AlphaBeta", (ConstraintValidatorContext) null);
+        // then
+        assertTrue(result);
+    }
+
+    @Test
+    public void isValidShouldReturnFalseWhenValueContainsNotAllowedCharacters() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", "[^a-zA-Z]");
+        // when
+        boolean result = validator.isValid("Alpha1", (ConstraintValidatorContext) null);
+        // then
+        assertFalse(result);
+    }
+
+    @Test
+    public void isValidShouldTrimValueBeforeValidation() {
+        // given
+        ReflectionTestUtils.setField(validator, "allowedCharactersRegex", "[^a-zA-Z]");
+        // when
+        boolean result = validator.isValid("  Alpha  ", (ConstraintValidatorContext) null);
+        // then
+        assertTrue(result);
+    }
+
+}

admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/impl/CacheManagementServiceImplTest.java

@@ -0,0 +1,121 @@
+package io.mosip.kernel.masterdata.test.impl;
+
+import io.mosip.kernel.masterdata.service.impl.CacheManagementServiceImpl;
+import io.mosip.kernel.masterdata.utils.CacheName;
+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.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.mockito.Mockito.*;
+
+
+@RunWith(MockitoJUnitRunner.class)
+public class CacheManagementServiceImplTest {
+
+    @Mock
+    private CacheManager cacheManager;
+
+    @Mock
+    private Cache cache1;
+
+    @Mock
+    private Cache cache2;
+
+    @InjectMocks
+    private CacheManagementServiceImpl cacheManagementService;
+
+
+    @Test
+    public void clearCacheByCacheNameShouldClearMatchingCache() {
+        // given
+        CacheName cacheName = CacheName.DOCUMENT_CATEGORY;
+        Set<String> cacheNames = new HashSet<>();
+        cacheNames.add(cacheName.getName());
+        when(cacheManager.getCacheNames()).thenReturn(cacheNames);
+        when(cacheManager.getCache(cacheName.getName())).thenReturn(cache1);
+        // when
+        cacheManagementService.clearCacheByCacheName(cacheName);
+        // then
+        verify(cacheManager, times(1)).getCacheNames();
+        verify(cacheManager, times(1)).getCache(cacheName.getName());
+        verify(cache1, times(1)).clear();
+        verifyNoMoreInteractions(cache1);
+    }
+
+    @Test
+    public void clearCacheByCacheNameShouldNotFailWhenCacheIsNull() {
+        // given
+        CacheName cacheName = CacheName.BLOCK_LISTED_WORDS;
+        Set<String> cacheNames = new HashSet<>();
+        cacheNames.add(cacheName.getName());
+        when(cacheManager.getCacheNames()).thenReturn(cacheNames);
+        when(cacheManager.getCache(cacheName.getName())).thenReturn(null);
+        // when
+        cacheManagementService.clearCacheByCacheName(cacheName);
+        // then
+        verify(cacheManager, times(1)).getCacheNames();
+        verify(cacheManager, times(1)).getCache(cacheName.getName());
+        verifyNoInteractions(cache1, cache2);
+    }
+
+    @Test
+    public void clearCacheByCacheNameShouldDoNothingWhenNoNameMatches() {
+        // given
+        CacheName cacheName = CacheName.DYNAMIC_FIELD;
+        Set<String> cacheNames = new HashSet<>(Arrays.asList("OTHER_CACHE_1", "OTHER_CACHE_2"));
+        when(cacheManager.getCacheNames()).thenReturn(cacheNames);
+        when(cacheManager.getCache("OTHER_CACHE_1")).thenReturn(cache1);
+        when(cacheManager.getCache("OTHER_CACHE_2")).thenReturn(cache2);
+        // when
+        cacheManagementService.clearCacheByCacheName(cacheName);
+        // then
+        verify(cacheManager, times(1)).getCacheNames();
+        verify(cacheManager, times(1)).getCache("OTHER_CACHE_1");
+        verify(cacheManager, times(1)).getCache("OTHER_CACHE_2");
+        verify(cache1, never()).clear();
+        verify(cache2, never()).clear();
+    }
+
+    @Test
+    public void clearCacheShouldClearAllNonNullCaches() {
+        // given
+        Set<String> cacheNames = new HashSet<>(Arrays.asList("cache1", "cache2"));
+        when(cacheManager.getCacheNames()).thenReturn(cacheNames);
+        when(cacheManager.getCache("cache1")).thenReturn(cache1);
+        when(cacheManager.getCache("cache2")).thenReturn(cache2);
+        // when
+        cacheManagementService.clearCache();
+        // then
+        verify(cacheManager, times(1)).getCacheNames();
+        verify(cacheManager, times(1)).getCache("cache1");
+        verify(cacheManager, times(1)).getCache("cache2");
+        verify(cache1, times(1)).clear();
+        verify(cache2, times(1)).clear();
+    }
+
+    @Test
+    public void clearCacheShouldIgnoreNullCaches() {
+        // given
+        Set<String> cacheNames = new HashSet<>(Arrays.asList("cache1", "cache2"));
+        when(cacheManager.getCacheNames()).thenReturn(cacheNames);
+        when(cacheManager.getCache("cache1")).thenReturn(cache1);
+        when(cacheManager.getCache("cache2")).thenReturn(null);
+        // when
+        cacheManagementService.clearCache();
+        // then
+        verify(cacheManager, times(1)).getCacheNames();
+        verify(cacheManager, times(1)).getCache("cache1");
+        verify(cacheManager, times(1)).getCache("cache2");
+        verify(cache1, times(1)).clear();  // seul cache1 non null
+        verifyNoMoreInteractions(cache1);
+    }
+
+}

admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/CenterTypeCodeValidatorTest.java

@@ -0,0 +1,57 @@
+package io.mosip.kernel.masterdata.test.validator;
+
+import io.mosip.kernel.masterdata.validator.CenterTypeCodeValidator;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CenterTypeCodeValidatorTest {
+
+    private CenterTypeCodeValidator validator;
+
+    @BeforeEach
+    void setup() {
+        validator = new CenterTypeCodeValidator();
+        // Simulation de l’injection @Value
+        validator.setCenterTypeCodeValidate("^[A-Z]{3}[0-9]{2}$");
+        // Exemple de regex : 3 lettres + 2 chiffres
+    }
+
+    @Test
+    void testValidValue() {
+        boolean result = validator.isValid("ABC12", null);
+        assertTrue(result);
+    }
+
+    @Test
+    void testInvalidValue() {
+        boolean result = validator.isValid("A12", null);
+        assertFalse(result);
+    }
+
+    @Test
+    void testLowercaseInvalid() {
+        boolean result = validator.isValid("abc12", null);
+        assertFalse(result);
+    }
+
+    @Test
+    void testNullValueThrowsException() {
+        assertThrows(NullPointerException.class, () -> validator.isValid(null, null));
+    }
+
+    @Test
+    void testEmptyValue() {
+        boolean result = validator.isValid("", null);
+        assertFalse(result);
+    }
+
+    @Test
+    void testRegexChange() {
+        validator.setCenterTypeCodeValidate("^[0-9]{4}$");
+        assertTrue(validator.isValid("1234", null));
+        assertFalse(validator.isValid("ABC1", null));
+    }
+
+}

admin/kernel-masterdata-service/src/test/java/io/mosip/kernel/masterdata/test/validator/CustomIntegerDeserializerTest.java

@@ -0,0 +1,58 @@
+package io.mosip.kernel.masterdata.test.validator;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import io.mosip.kernel.masterdata.validator.CustomIntegerDeserializer;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CustomIntegerDeserializerTest {
+
+    private ObjectMapper buildMapper() {
+        ObjectMapper mapper = new ObjectMapper();
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(Object.class, new CustomIntegerDeserializer());
+        mapper.registerModule(module);
+        return mapper;
+    }
+
+    @Test
+    void testValidInteger() throws Exception {
+        ObjectMapper mapper = buildMapper();
+        String json = "123";
+        Object result = mapper.readValue(json, Object.class);
+        assertTrue(result instanceof Integer);
+        assertEquals(123, result);
+    }
+
+    @Test
+    void testInvalidFloat() {
+        ObjectMapper mapper = buildMapper();
+        String json = "123.45";
+        Exception ex = assertThrows(IOException.class, () -> {
+            mapper.readValue(json, Object.class);
+        });
+        assertTrue(ex.getMessage().contains("Cannot coerce"));
+    }
+
+    @Test
+    void testNullValue() throws Exception {
+        ObjectMapper mapper = buildMapper();
+        String json = "null";
+        Object result = mapper.readValue(json, Object.class);
+        assertNull(result);
+    }
+
+    @Test
+    void testInvalidString() {
+        ObjectMapper mapper = buildMapper();
+        String json = "\"abc\"";
+        assertThrows(IOException.class, () -> {
+            mapper.readValue(json, Object.class);
+        });
+    }
+
+}