From a65f753f700af92f35399ad12af114feb41bbfa7 Mon Sep 17 00:00:00 2001 From: Venkata Saidurga Polamraju Date: Wed, 13 Mar 2024 13:51:03 +0530 Subject: [PATCH] [MOSIP-30573] Signed-off-by: Venkata Saidurga Polamraju --- .../exception/ClientCryptoExceptionTest.java | 30 +++++ .../CryptoManagerServiceExceptionTest.java | 26 ++++ .../KeymanagerServiceExceptionTest.java | 22 ++++ .../exception/ParseResponseExceptionTest.java | 26 ++++ .../hsm/test/HSMHealthCheckTest.java | 45 +++++++ .../hsm/test/OLKeyStoreImplTest.java | 123 ++++++++++++++++++ .../service/test/KeyMigratorServiceTest.java | 50 +++++++ .../InvalidArguementsExceptionTest.java | 39 ++++++ .../test/util/LicenseKeyManagerUtilTest.java | 102 +++++++++++++++ .../PartnerCertManagerControllerTest.java | 56 ++++++++ .../PartnerCertManagerExceptionTest.java | 21 +++ .../helper/PartnerCertDBHelperTest.java | 67 ++++++++++ .../CertificateNotValidExceptionTest.java | 29 +++++ .../exeption/PublicKeyParseExceptionTest.java | 20 +++ .../exeption/RequestExceptionTest.java | 29 +++++ .../SignatureFailureExceptionTest.java | 20 +++ .../integration/util/SignatureUtilTest.java | 66 ++++++++++ .../TokenIdGeneratorServiceExceptionTest.java | 18 +++ .../exception/ZKCryptoExceptionTest.java | 27 ++++ .../ZKKeyDerivationExceptionTest.java | 29 +++++ .../ZKRandomKeyDecryptionExceptionTest.java | 16 +++ 21 files changed, 861 insertions(+) create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/clientcrypto/test/exception/ClientCryptoExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/CryptoManagerServiceExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/KeymanagerServiceExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/ParseResponseExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/HSMHealthCheckTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/OLKeyStoreImplTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymigrate/service/test/KeyMigratorServiceTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/exception/InvalidArguementsExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/util/LicenseKeyManagerUtilTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/controller/PartnerCertManagerControllerTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/exception/PartnerCertManagerExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/helper/PartnerCertDBHelperTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/CertificateNotValidExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/PublicKeyParseExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/RequestExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/SignatureFailureExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/util/SignatureUtilTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/tokenidgenerator/test/integration/exception/TokenIdGeneratorServiceExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKCryptoExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKKeyDerivationExceptionTest.java create mode 100644 kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKRandomKeyDecryptionExceptionTest.java diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/clientcrypto/test/exception/ClientCryptoExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/clientcrypto/test/exception/ClientCryptoExceptionTest.java new file mode 100644 index 00000000..f75d9cfc --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/clientcrypto/test/exception/ClientCryptoExceptionTest.java @@ -0,0 +1,30 @@ +package io.mosip.kernel.clientcrypto.test.exception; + +import io.mosip.kernel.clientcrypto.exception.ClientCryptoException; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class ClientCryptoExceptionTest { + + @Test + public void testConstructorWithErrorCodeAndMessage() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + + ClientCryptoException exception = new ClientCryptoException(errorCode, errorMessage); + + assertEquals(errorCode, exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorCodeMessageAndRootCause() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + Throwable rootCause = new RuntimeException("Root cause exception"); + + ClientCryptoException exception = new ClientCryptoException(errorCode, errorMessage, rootCause); + + assertEquals(errorCode, exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/CryptoManagerServiceExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/CryptoManagerServiceExceptionTest.java new file mode 100644 index 00000000..c07dc804 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/CryptoManagerServiceExceptionTest.java @@ -0,0 +1,26 @@ +package io.mosip.kernel.cryptomanager.test.exception; + +import io.mosip.kernel.cryptomanager.exception.CryptoManagerSerivceException; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class CryptoManagerServiceExceptionTest { + + @Test + public void testConstructorWithErrorCodeAndMessage() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + CryptoManagerSerivceException exception = new CryptoManagerSerivceException(errorCode, errorMessage); + assertEquals(errorCode, exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorCodeMessageAndRootCause() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + Throwable rootCause = new RuntimeException("Root cause exception"); + CryptoManagerSerivceException exception = new CryptoManagerSerivceException(errorCode, errorMessage); + assertEquals(errorCode, exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/KeymanagerServiceExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/KeymanagerServiceExceptionTest.java new file mode 100644 index 00000000..1352ae58 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/KeymanagerServiceExceptionTest.java @@ -0,0 +1,22 @@ +package io.mosip.kernel.cryptomanager.test.exception; + +import io.mosip.kernel.core.exception.ServiceError; +import io.mosip.kernel.cryptomanager.exception.KeymanagerServiceException; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertEquals; + +public class KeymanagerServiceExceptionTest { + @Test + public void testKeymanagerServiceException() { + List errorList = new ArrayList<>(); + errorList.add(new ServiceError("errorCode1", "errorDescription1")); + errorList.add(new ServiceError("errorCode2", "errorDescription2")); + KeymanagerServiceException exception = new KeymanagerServiceException(errorList); + List exceptionErrorList = exception.getList(); + assertEquals(errorList, exceptionErrorList); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/ParseResponseExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/ParseResponseExceptionTest.java new file mode 100644 index 00000000..738e22f7 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/cryptomanager/test/exception/ParseResponseExceptionTest.java @@ -0,0 +1,26 @@ +package io.mosip.kernel.cryptomanager.test.exception; + +import io.mosip.kernel.cryptomanager.exception.ParseResponseException; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class ParseResponseExceptionTest { + + @Test + public void testConstructorWithErrorCodeAndMessage() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + ParseResponseException exception = new ParseResponseException(errorCode, errorMessage); + assertEquals(errorCode, exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorCodeMessageAndRootCause() { + String errorCode = "ERR_CRYPTO_001"; + String errorMessage = "Crypto error"; + Throwable rootCause = new RuntimeException("Root cause exception"); + ParseResponseException exception = new ParseResponseException(errorCode, errorMessage,rootCause); + assertEquals(errorCode, exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/HSMHealthCheckTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/HSMHealthCheckTest.java new file mode 100644 index 00000000..de18c6f1 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/HSMHealthCheckTest.java @@ -0,0 +1,45 @@ +package io.mosip.kernel.keymanager.hsm.test; + +import io.mosip.kernel.core.keymanager.spi.KeyStore; +import io.mosip.kernel.core.util.CryptoUtil; +import io.mosip.kernel.keymanager.hsm.health.HSMHealthCheck; +import io.mosip.kernel.keymanagerservice.helper.KeymanagerDBHelper; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.*; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.boot.actuate.health.Health; +import org.springframework.boot.actuate.health.Status; +import reactor.core.publisher.Mono; + +import static org.junit.Assert.assertEquals; + +@RunWith(MockitoJUnitRunner.class) +public class HSMHealthCheckTest { + @Mock + private KeyStore keyStore; + + @Mock + private CryptoUtil cryptoUtil; + + @Mock + private KeymanagerDBHelper dbHelper; + + @InjectMocks + private HSMHealthCheck hsmHealthCheck; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testHealthCheckDisabled() throws Exception { + Mono healthMono = hsmHealthCheck.health(); + Health health = healthMono.block(); + assertEquals(Status.UP, health.getStatus()); + assertEquals("HEALTH_CHECK_NOT_ENABLED", health.getDetails().get("Info: ")); + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/OLKeyStoreImplTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/OLKeyStoreImplTest.java new file mode 100644 index 00000000..32838441 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymanager/hsm/test/OLKeyStoreImplTest.java @@ -0,0 +1,123 @@ +package io.mosip.kernel.keymanager.hsm.test; + +import io.mosip.kernel.core.keymanager.exception.KeystoreProcessingException; +import io.mosip.kernel.core.keymanager.model.CertificateParameters; +import io.mosip.kernel.keymanager.hsm.constant.KeymanagerErrorCode; +import io.mosip.kernel.keymanager.hsm.impl.offline.OLKeyStoreImpl; +import org.junit.Test; +import static org.junit.Assert.assertEquals; + +public class OLKeyStoreImplTest { + + @Test + public void testGetAllAlias() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getAllAlias(); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetAsymmetricKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getAsymmetricKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetPrivateKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getPrivateKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetPublicKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getPublicKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetCertificate() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getCertificate("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetSymmetricKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getSymmetricKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testDeleteKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.deleteKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGenerateAndStoreAsymmetricKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + CertificateParameters certificateParameters=new CertificateParameters(); + keystore.generateAndStoreAsymmetricKey("alias","signKeyAlias",certificateParameters); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGenerateAndStoreSymmetricKey() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.generateAndStoreSymmetricKey("alias"); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + + @Test + public void testGetKeystoreProviderName() throws Exception { + OLKeyStoreImpl keystore = new OLKeyStoreImpl(null); + try { + keystore.getKeystoreProviderName(); + } catch (KeystoreProcessingException e) { + assertEquals(KeymanagerErrorCode.OFFLINE_KEYSTORE_ACCESS_ERROR.getErrorCode(), e.getErrorCode()); + } + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymigrate/service/test/KeyMigratorServiceTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymigrate/service/test/KeyMigratorServiceTest.java new file mode 100644 index 00000000..6d140843 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/keymigrate/service/test/KeyMigratorServiceTest.java @@ -0,0 +1,50 @@ +package io.mosip.kernel.keymigrate.service.test; +import io.mosip.kernel.keymigrate.dto.KeyMigrateBaseKeyRequestDto; +import io.mosip.kernel.keymigrate.dto.KeyMigrateBaseKeyResponseDto; +import io.mosip.kernel.keymigrate.dto.ZKKeyMigrateCertficateResponseDto; +import io.mosip.kernel.keymigrate.dto.ZKKeyMigrateRequestDto; +import io.mosip.kernel.keymigrate.dto.ZKKeyMigrateResponseDto; +import io.mosip.kernel.keymigrate.service.spi.KeyMigratorService; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.mockito.Mockito.when; + +public class KeyMigratorServiceTest { + + @Mock + private KeyMigratorService keyMigratorService; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testMigrateBaseKey() { + KeyMigrateBaseKeyRequestDto requestDto = new KeyMigrateBaseKeyRequestDto(); + KeyMigrateBaseKeyResponseDto expectedResponse = new KeyMigrateBaseKeyResponseDto(); + when(keyMigratorService.migrateBaseKey(requestDto)).thenReturn(expectedResponse); + KeyMigrateBaseKeyResponseDto actualResponse = keyMigratorService.migrateBaseKey(requestDto); + Assert.assertEquals(expectedResponse, actualResponse); + } + + @Test + public void testGetZKTempCertificate() { + ZKKeyMigrateCertficateResponseDto expectedResponse = new ZKKeyMigrateCertficateResponseDto(); + when(keyMigratorService.getZKTempCertificate()).thenReturn(expectedResponse); + ZKKeyMigrateCertficateResponseDto actualResponse = keyMigratorService.getZKTempCertificate(); + Assert.assertEquals(expectedResponse, actualResponse); + } + + @Test + public void testMigrateZKKeys() { + ZKKeyMigrateRequestDto requestDto = new ZKKeyMigrateRequestDto(); + ZKKeyMigrateResponseDto expectedResponse = new ZKKeyMigrateResponseDto(); + when(keyMigratorService.migrateZKKeys(requestDto)).thenReturn(expectedResponse); + ZKKeyMigrateResponseDto actualResponse = keyMigratorService.migrateZKKeys(requestDto); + Assert.assertEquals(expectedResponse, actualResponse); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/exception/InvalidArguementsExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/exception/InvalidArguementsExceptionTest.java new file mode 100644 index 00000000..76fbee4c --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/exception/InvalidArguementsExceptionTest.java @@ -0,0 +1,39 @@ +package io.mosip.kernel.lkeymanager.test.exception; + +import io.mosip.kernel.core.exception.ServiceError; +import io.mosip.kernel.lkeymanager.exception.InvalidArgumentsException; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.ArrayList; +import java.util.List; + +@RunWith(MockitoJUnitRunner.class) +public class InvalidArguementsExceptionTest { + + @Mock + private InvalidArgumentsException exception; + + @Test + public void testGetList() { + List errorList = new ArrayList<>(); + errorList.add(new ServiceError("ERROR_CODE_1", "Error 1")); + errorList.add(new ServiceError("ERROR_CODE_2", "Error 2")); + Mockito.when(exception.getList()).thenReturn(errorList); + List retrievedList = exception.getList(); + Assert.assertEquals(errorList, retrievedList); + } + + @Test + public void testGetList_EmptyList() { + List errorList = new ArrayList<>(); + Mockito.when(exception.getList()).thenReturn(errorList); + List retrievedList = exception.getList(); + Assert.assertTrue(retrievedList.isEmpty()); + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/util/LicenseKeyManagerUtilTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/util/LicenseKeyManagerUtilTest.java new file mode 100644 index 00000000..866885e5 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/lkeymanager/test/util/LicenseKeyManagerUtilTest.java @@ -0,0 +1,102 @@ +package io.mosip.kernel.lkeymanager.test.util; +import io.mosip.kernel.lkeymanager.exception.InvalidArgumentsException; +import io.mosip.kernel.lkeymanager.util.LicenseKeyManagerUtil; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.Arrays; +import java.util.List; + +@RunWith(MockitoJUnitRunner.class) +public class LicenseKeyManagerUtilTest { + @InjectMocks + private LicenseKeyManagerUtil licenseKeyManagerUtil; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testConcatPermissionsIntoASingleRow() { + List permissionsList = Arrays.asList("permission1", "permission2", "permission3"); + String expected = "permission1,permission2,permission3"; + + String result = licenseKeyManagerUtil.concatPermissionsIntoASingleRow(permissionsList); + + Assert.assertEquals(expected, result); + } + + @Test + public void testValidateTSP_ValidTSP() { + String tspID = "TSP123"; + licenseKeyManagerUtil.validateTSP(tspID); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateTSP_InvalidTSP() { + String tspID = null; + licenseKeyManagerUtil.validateTSP(tspID); + } + + @Test + public void testValidateTSPAndLicenseKey_ValidTSPAndLicenseKey() { + String tspID = "TSP123"; + String licenseKey = "ABC123xyz"; + licenseKeyManagerUtil.validateTSPAndLicenseKey(tspID, licenseKey); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateTSPAndLicenseKey_InvalidTSP() { + String tspID = null; + String licenseKey = "ABC123xyz"; + licenseKeyManagerUtil.validateTSPAndLicenseKey(tspID, licenseKey); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateTSPAndLicenseKey_InvalidLicenseKey() { + String tspID = "TSP123"; + String licenseKey = null; + + licenseKeyManagerUtil.validateTSPAndLicenseKey(tspID, licenseKey); + } + + @Test + public void testValidateRequestParameters_ValidParameters() { + String tspID = "TSP123"; + String licenseKey = "ABC123xyz"; + List permissions= Arrays.asList("permission1", "permission2"); + + licenseKeyManagerUtil.validateRequestParameters(tspID, licenseKey, permissions); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateRequestParameters_InvalidTSP() { + String tspID = null; + String licenseKey = "ABC123xyz"; + List permissions = Arrays.asList("permission1", "permission2"); + + licenseKeyManagerUtil.validateRequestParameters(tspID, licenseKey, permissions); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateRequestParameters_InvalidLicenseKey() { + String tspID = "TSP123"; + String licenseKey = null; + List permissions = Arrays.asList("permission1", "permission2"); + licenseKeyManagerUtil.validateRequestParameters(tspID, licenseKey, permissions); + } + + @Test(expected = InvalidArgumentsException.class) + public void testValidateRequestParameters_InvalidPermission() { + String tspID = "TSP123"; + String licenseKey = "ABC123xyz"; + List permissions = Arrays.asList("permission1", ""); + licenseKeyManagerUtil.validateRequestParameters(tspID, licenseKey, permissions); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/controller/PartnerCertManagerControllerTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/controller/PartnerCertManagerControllerTest.java new file mode 100644 index 00000000..30c23a6b --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/controller/PartnerCertManagerControllerTest.java @@ -0,0 +1,56 @@ +package io.mosip.kernel.partnercertservice.controller; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import io.mosip.kernel.partnercertservice.dto.CACertificateRequestDto; +import io.mosip.kernel.partnercertservice.dto.PartnerCertDownloadRequestDto; +import io.mosip.kernel.partnercertservice.dto.PartnerCertDownloadResponeDto; +import io.mosip.kernel.partnercertservice.service.spi.PartnerCertificateManagerService; +import io.mosip.kernel.core.http.RequestWrapper; +import io.mosip.kernel.core.http.ResponseWrapper; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.security.access.AccessDeniedException; + +public class PartnerCertManagerControllerTest { + + @Mock + private PartnerCertificateManagerService partnerCertManagerService; + + @InjectMocks + private PartnerCertManagerController partnerCertManagerController; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testGetPartnerCertificate() { + String partnerCertId = "12345"; + PartnerCertDownloadRequestDto requestDto = new PartnerCertDownloadRequestDto(); + requestDto.setPartnerCertId(partnerCertId); + PartnerCertDownloadResponeDto responseDto = new PartnerCertDownloadResponeDto(); + ResponseWrapper expectedResponse = new ResponseWrapper<>(); + expectedResponse.setResponse(responseDto); + when(partnerCertManagerService.getPartnerCertificate(any())).thenReturn(responseDto); + ResponseWrapper actualResponse = partnerCertManagerController.getPartnerCertificate(partnerCertId); + expectedResponse.setResponsetime(actualResponse.getResponsetime()); + + assertEquals(expectedResponse, actualResponse); + } + + @Test(expected = AccessDeniedException.class) + public void testAccessDeniedException() { + + CACertificateRequestDto requestDto = new CACertificateRequestDto(); + RequestWrapper requestWrapper = new RequestWrapper<>(); + when(partnerCertManagerService.uploadCACertificate(any())).thenThrow(AccessDeniedException.class); + partnerCertManagerController.uploadCACertificate(requestWrapper); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/exception/PartnerCertManagerExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/exception/PartnerCertManagerExceptionTest.java new file mode 100644 index 00000000..14316346 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/exception/PartnerCertManagerExceptionTest.java @@ -0,0 +1,21 @@ +package io.mosip.kernel.partnercertservice.exception; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class PartnerCertManagerExceptionTest { + + @Test + public void testConstructorWithErrorCodeAndErrorMessage() { + PartnerCertManagerException exception = new PartnerCertManagerException("ERROR_CODE", "Error message"); + assertEquals("ERROR_CODE", exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorCodeErrorMessageAndRootCause() { + Exception rootCause = new Exception("Root cause"); + PartnerCertManagerException exception = new PartnerCertManagerException("ERROR_CODE", "Error message", rootCause); + assertEquals("ERROR_CODE", exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/helper/PartnerCertDBHelperTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/helper/PartnerCertDBHelperTest.java new file mode 100644 index 00000000..4556e388 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/partnercertservice/helper/PartnerCertDBHelperTest.java @@ -0,0 +1,67 @@ +package io.mosip.kernel.partnercertservice.helper; + +import io.mosip.kernel.keymanagerservice.entity.CACertificateStore; +import io.mosip.kernel.keymanagerservice.entity.PartnerCertificateStore; +import io.mosip.kernel.keymanagerservice.repository.CACertificateStoreRepository; +import io.mosip.kernel.keymanagerservice.repository.PartnerCertificateStoreRepository; +import io.mosip.kernel.keymanagerservice.util.KeymanagerUtil; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.*; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +public class PartnerCertDBHelperTest { + + @Mock + private CACertificateStoreRepository caCertificateStoreRepository; + + @Mock + private PartnerCertificateStoreRepository partnerCertificateStoreRepository; + + @Mock + private KeymanagerUtil keymanagerUtil; + + @InjectMocks + private PartnerCertManagerDBHelper partnerCertManagerDBHelper; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testIsCertificateExist_WhenCertificateExists() { + when(caCertificateStoreRepository.findByCertThumbprintAndPartnerDomain(anyString(), anyString())).thenReturn(new CACertificateStore()); + boolean result = partnerCertManagerDBHelper.isCertificateExist("thumbprint", "partnerDomain"); + Assert.assertTrue(result); + } + + @Test + public void testIsCertificateExist_WhenCertificateDoesNotExist() { + when(caCertificateStoreRepository.findByCertThumbprintAndPartnerDomain(anyString(), anyString())).thenReturn(null); + boolean result = partnerCertManagerDBHelper.isCertificateExist("thumbprint", "partnerDomain"); + Assert.assertFalse(result); + } + + @Test + public void testIsPartnerCertificateExist_WhenCertificateExists() { + when(partnerCertificateStoreRepository.findByCertThumbprintAndPartnerDomain(anyString(), anyString())).thenReturn(Collections.singletonList(new PartnerCertificateStore())); + boolean result = partnerCertManagerDBHelper.isPartnerCertificateExist("thumbprint", "partnerDomain"); + Assert.assertTrue(result); + } + + @Test + public void testIsPartnerCertificateExist_WhenCertificateDoesNotExist() { + when(partnerCertificateStoreRepository.findByCertThumbprintAndPartnerDomain(anyString(), anyString())).thenReturn(Collections.emptyList()); + boolean result = partnerCertManagerDBHelper.isPartnerCertificateExist("thumbprint", "partnerDomain"); + Assert.assertFalse(result); + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/CertificateNotValidExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/CertificateNotValidExceptionTest.java new file mode 100644 index 00000000..82e80621 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/CertificateNotValidExceptionTest.java @@ -0,0 +1,29 @@ +package io.mosip.kernel.signature.test.integration.exeption; +import io.mosip.kernel.signature.exception.CertificateNotValidException; +import org.junit.Assert; +import org.junit.Test; + +public class CertificateNotValidExceptionTest { + @Test + public void testConstructorWithErrorCodeAndErrorMessage() { + String errorCode = "ERR001"; + String errorMessage = "Certificate is not valid"; + + CertificateNotValidException exception = new CertificateNotValidException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertNull(exception.getCause()); + } + + @Test + public void testConstructorWithErrorCodeErrorMessageAndRootCause() { + String errorCode = "ERR001"; + String errorMessage = "Certificate is not valid"; + Throwable rootCause = new RuntimeException("Root cause"); + + CertificateNotValidException exception = new CertificateNotValidException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertEquals(rootCause, exception.getCause()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/PublicKeyParseExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/PublicKeyParseExceptionTest.java new file mode 100644 index 00000000..bd2e396d --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/PublicKeyParseExceptionTest.java @@ -0,0 +1,20 @@ +package io.mosip.kernel.signature.test.integration.exeption; + +import io.mosip.kernel.signature.exception.PublicKeyParseException; +import org.junit.Assert; +import org.junit.Test; + +public class PublicKeyParseExceptionTest { + + @Test + public void testConstructorWithErrorCodeErrorMessageAndRootCause() { + String errorCode = "ERR001"; + String errorMessage = "Error parsing public key"; + Throwable rootCause = new RuntimeException("Root cause"); + + PublicKeyParseException exception = new PublicKeyParseException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertEquals(rootCause, exception.getCause()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/RequestExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/RequestExceptionTest.java new file mode 100644 index 00000000..e8b85371 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/RequestExceptionTest.java @@ -0,0 +1,29 @@ +package io.mosip.kernel.signature.test.integration.exeption; +import io.mosip.kernel.signature.exception.RequestException; +import org.junit.Assert; +import org.junit.Test; +public class RequestExceptionTest { + + @Test + public void testConstructorWithErrorCodeAndErrorMessage() { + String errorCode = "ERR001"; + String errorMessage = "Invalid request"; + + RequestException exception = new RequestException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertNull(exception.getCause()); + } + + @Test + public void testConstructorWithErrorCodeErrorMessageAndRootCause() { + String errorCode = "ERR001"; + String errorMessage = "Invalid request"; + Throwable rootCause = new RuntimeException("Root cause"); + + RequestException exception = new RequestException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertEquals(rootCause, exception.getCause()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/SignatureFailureExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/SignatureFailureExceptionTest.java new file mode 100644 index 00000000..437432d9 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/exeption/SignatureFailureExceptionTest.java @@ -0,0 +1,20 @@ +package io.mosip.kernel.signature.test.integration.exeption; + +import io.mosip.kernel.signature.exception.SignatureFailureException; +import org.junit.Assert; +import org.junit.Test; + +public class SignatureFailureExceptionTest { + + @Test + public void testConstructorWithErrorCodeErrorMessageAndRootCause() { + String errorCode = "ERR001"; + String errorMessage = "Signature failure"; + Throwable rootCause = new RuntimeException("Root cause"); + + SignatureFailureException exception = new SignatureFailureException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + Assert.assertEquals(rootCause, exception.getCause()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/util/SignatureUtilTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/util/SignatureUtilTest.java new file mode 100644 index 00000000..a4ea4717 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/signature/test/integration/util/SignatureUtilTest.java @@ -0,0 +1,66 @@ +package io.mosip.kernel.signature.test.integration.util; + +import com.nimbusds.jose.JWSAlgorithm; +import com.nimbusds.jose.JWSHeader; +import io.mosip.kernel.signature.util.SignatureUtil; +import org.junit.Assert; +import org.junit.Test; +import org.mockito.Mockito; + +import java.security.cert.CertificateEncodingException; +import java.security.cert.X509Certificate; +import java.util.Date; + +public class SignatureUtilTest { + @Test + public void testIsDataValid() { + String validData = "Valid data"; + String emptyData = ""; + String nullData = null; + + Assert.assertTrue(SignatureUtil.isDataValid(validData)); + Assert.assertFalse(SignatureUtil.isDataValid(emptyData)); + Assert.assertFalse(SignatureUtil.isDataValid(nullData)); + } + + @Test + public void testIsJsonValid() { + String validJson = "{\"name\":\"John\",\"age\":30}"; + String invalidJson = "{\"name\":\"John\",\"age\":30"; + + Assert.assertTrue(SignatureUtil.isJsonValid(validJson)); + Assert.assertFalse(SignatureUtil.isJsonValid(invalidJson)); + } + + @Test + public void testIsIncludeAttrsValid() { + Boolean includesTrue = true; + Boolean includesFalse = false; + Boolean includesNull = null; + + Assert.assertTrue(SignatureUtil.isIncludeAttrsValid(includesTrue)); + Assert.assertFalse(SignatureUtil.isIncludeAttrsValid(includesFalse)); + } + + @Test + public void testIsCertificateDatesValid() throws CertificateEncodingException { + X509Certificate validCertificate = Mockito.mock(X509Certificate.class); + X509Certificate expiredCertificate = Mockito.mock(X509Certificate.class); + X509Certificate notYetValidCertificate = Mockito.mock(X509Certificate.class); + + Mockito.when(validCertificate.getEncoded()).thenReturn(new byte[]{}); + Mockito.when(expiredCertificate.getEncoded()).thenThrow(CertificateEncodingException.class); + Mockito.when(notYetValidCertificate.getEncoded()).thenThrow(CertificateEncodingException.class); + + Assert.assertTrue(SignatureUtil.isCertificateDatesValid(validCertificate)); + } + + @Test + public void testBuildSignData() { + JWSHeader jwsHeader = new JWSHeader.Builder(JWSAlgorithm.RS256).build(); + byte[] actualDataToSign = "DataToSign".getBytes(); + + byte[] signData = SignatureUtil.buildSignData(jwsHeader, actualDataToSign); + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/tokenidgenerator/test/integration/exception/TokenIdGeneratorServiceExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/tokenidgenerator/test/integration/exception/TokenIdGeneratorServiceExceptionTest.java new file mode 100644 index 00000000..d0b8d3e2 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/tokenidgenerator/test/integration/exception/TokenIdGeneratorServiceExceptionTest.java @@ -0,0 +1,18 @@ +package io.mosip.kernel.tokenidgenerator.test.integration.exception; + +import io.mosip.kernel.tokenidgenerator.exception.TokenIdGeneratorServiceException; +import org.junit.Assert; +import org.junit.Test; + +public class TokenIdGeneratorServiceExceptionTest { + + @Test + public void testConstructor() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + + TokenIdGeneratorServiceException exception = new TokenIdGeneratorServiceException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKCryptoExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKCryptoExceptionTest.java new file mode 100644 index 00000000..f08b37b6 --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKCryptoExceptionTest.java @@ -0,0 +1,27 @@ +package io.mosip.kernel.zkcryptoservice.exception; + +import org.junit.Assert; +import org.junit.Test; + +public class ZKCryptoExceptionTest { + @Test + public void testConstructorWithErrorMessage() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + + ZKCryptoException exception = new ZKCryptoException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorMessageAndRootCause() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + Throwable rootCause = new RuntimeException("Root cause"); + + ZKCryptoException exception = new ZKCryptoException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKKeyDerivationExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKKeyDerivationExceptionTest.java new file mode 100644 index 00000000..ef314eab --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKKeyDerivationExceptionTest.java @@ -0,0 +1,29 @@ +package io.mosip.kernel.zkcryptoservice.exception; + +import org.junit.Assert; +import org.junit.Test; + +public class ZKKeyDerivationExceptionTest { + + @Test + public void testConstructorWithErrorMessage() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + + ZKKeyDerivationException exception = new ZKKeyDerivationException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } + + @Test + public void testConstructorWithErrorMessageAndRootCause() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + Throwable rootCause = new RuntimeException("Root cause"); + + ZKKeyDerivationException exception = new ZKKeyDerivationException(errorCode, errorMessage, rootCause); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } + +} diff --git a/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKRandomKeyDecryptionExceptionTest.java b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKRandomKeyDecryptionExceptionTest.java new file mode 100644 index 00000000..7d7d496f --- /dev/null +++ b/kernel/kernel-keymanager-service/src/test/java/io/mosip/kernel/zkcryptoservice/exception/ZKRandomKeyDecryptionExceptionTest.java @@ -0,0 +1,16 @@ +package io.mosip.kernel.zkcryptoservice.exception; + +import org.junit.Assert; +import org.junit.Test; + +public class ZKRandomKeyDecryptionExceptionTest { + @Test + public void testConstructorWithErrorMessage() { + String errorCode = "ERROR_CODE"; + String errorMessage = "Error message"; + + ZKRandomKeyDecryptionException exception = new ZKRandomKeyDecryptionException(errorCode, errorMessage); + + Assert.assertEquals(errorCode, exception.getErrorCode()); + } +}