From aa0a8ccc8652e8360f54c62bd312d5c5e2fef3c6 Mon Sep 17 00:00:00 2001 From: pvsaidurga <132046494+pvsaidurga@users.noreply.github.com> Date: Tue, 8 Oct 2024 20:53:52 +0530 Subject: [PATCH] [ES-1689] (#271) * [ES-1689] Signed-off-by: Venkata Saidurga Polamraju * [ES-1689] Signed-off-by: Venkata Saidurga Polamraju * [ES-1689] Updated the review comments Signed-off-by: Venkata Saidurga Polamraju --------- Signed-off-by: Venkata Saidurga Polamraju --- .../impl/AuthenticationServiceImplTest.java | 329 ++++++++++++++++++ .../service/impl/IdentityServiceTest.java | 91 +++++ 2 files changed, 420 insertions(+) diff --git a/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/AuthenticationServiceImplTest.java b/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/AuthenticationServiceImplTest.java index 571968dc..0dfc90e1 100644 --- a/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/AuthenticationServiceImplTest.java +++ b/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/AuthenticationServiceImplTest.java @@ -107,6 +107,200 @@ public void kycAuth_withValidKbiChallenge_thenPass() { Assert.assertTrue(kycAuthResponseDto.isAuthStatus()); } + @Test + public void kycAuth_withInvalidIdentity_thenFail() { + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setKbi("eyJmdWxsTmFtZSI6IlNpZGRoYXJ0aCBLIE1hbnNvdXIiLCJkYXRlT2ZCaXJ0aCI6IjE5ODctMTEtMjUifQ=="); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(null); + + try{ + authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + }catch (MockIdentityException e){ + Assert.assertEquals("invalid_individual_id",e.getMessage()); + } + } + + @Test + public void kycAuth_withoutSendOTPInvocation_thenFail() { + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setOtp("111111"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + try{ + authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + }catch (MockIdentityException e){ + Assert.assertEquals("invalid_transaction",e.getMessage()); + } + } + + @Test + public void kycAuth_withSendOTPInvocation_thenPass() { + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService,"otpChannels",Arrays.asList("email","phone")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + ReflectionTestUtils.setField(authenticationService,"trnHash",new ArrayList<>()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setOtp("111111"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + identityData.setIndividualId("individualId"); + identityData.setEmail("test@email.com"); + identityData.setPhone("1234567890"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + SendOtpDto sendOtpDto=new SendOtpDto(); + sendOtpDto.setIndividualId("individualId"); + sendOtpDto.setOtpChannels(Arrays.asList("email","phone")); + sendOtpDto.setTransactionId("transactionId"); + + Mockito.when(identityService.getIdentity("individualId")).thenReturn(identityData); + authenticationService.sendOtp("relyingPartyId", "clientId", sendOtpDto); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + Mockito.when(authRepository.save(Mockito.any())).thenReturn(new KycAuth()); + KycAuthResponseDto kycAuthResponseDto = authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + Assert.assertTrue(kycAuthResponseDto.isAuthStatus()); + } + + @Test + public void kycAuth_withInValidTransactionId_thenFail() { + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setOtp("111111"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId(""); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + try{ + authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + }catch (MockIdentityException e){ + Assert.assertEquals("invalid_transaction_id",e.getMessage()); + } + } + + @Test + public void kycAuth_withValidPinChallenge_thenPass() { + + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setPin("111111"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + Mockito.when(authRepository.save(Mockito.any())).thenReturn(new KycAuth()); + + KycAuthResponseDto kycAuthResponseDto = authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + Assert.assertTrue(kycAuthResponseDto.isAuthStatus()); + } + + @Test + public void kycAuth_withValidBiometricsChallenge_thenPass() { + + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setBiometrics("111111"); + kycAuthDto.setTokens(new ArrayList<>()); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + Mockito.when(authRepository.save(Mockito.any())).thenReturn(new KycAuth()); + + KycAuthResponseDto kycAuthResponseDto = authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + Assert.assertTrue(kycAuthResponseDto.isAuthStatus()); + } + + @Test + public void kycAuth_withValidPwdChallenge_thenPass() { + + List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") + ,Map.of("id","fullName","type","text","format","") + ,Map.of("id","dateOfBirth","type","date","format","yyyy-MM-dd")); + ReflectionTestUtils.setField(authenticationService, "fieldDetailList", fieldDetailList); + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setPassword("Mosip@123"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + identityData.setPassword("Mosip@123"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + + KycAuthResponseDto kycAuthResponseDto = authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + Assert.assertNotNull(kycAuthResponseDto); + } + @Test public void kycAuth_withValidKbiChallengeCustomPSUTfield_thenPass() { List> fieldDetailList = List.of(Map.of("id","individualId","type","text","format","string") @@ -195,6 +389,31 @@ public void kycAuth_withInValidKbiChallenge_thenFail() { } } + @Test + public void kycAuth_withEmptyKbiChallenge_thenFail() { + + ReflectionTestUtils.setField(authenticationService, "fieldLang", "eng"); + ReflectionTestUtils.setField(authenticationService,"objectMapper",new ObjectMapper()); + + KycAuthDto kycAuthDto = new KycAuthDto(); + kycAuthDto.setKbi("xsTmFtZSI6IlNpZG0aCBLIiwiZG9iIjoiMTk4Ny0xMS0yNSJ9"); + kycAuthDto.setIndividualId("individualId"); + kycAuthDto.setTransactionId("transactionId"); + + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValue = new LanguageValue(); + languageValue.setLanguage("eng"); + languageValue.setValue("Siddharth K Mansour"); + identityData.setFullName(List.of(languageValue)); + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(this.identityData); + try{ + authenticationService.kycAuth("relyingPartyId", "clientId", kycAuthDto); + }catch (MockIdentityException e){ + Assert.assertEquals("auth-failed",e.getMessage()); + } + } + @Test public void sendOtp_validIndividualIdAndOtpChannels_thenPass() throws MockIdentityException { ReflectionTestUtils.setField(authenticationService,"otpChannels",Arrays.asList("email","phone")); @@ -622,6 +841,116 @@ public void kycExchangeV2_withInValidIndividualId_thenFail() throws InvocationTa } } + @Test + public void kycExchangeV2_withDetailAndMatchedClaims_thenPass() { + Map oidcClaimsMap = new HashMap<>(); + oidcClaimsMap.put("name", "name"); + oidcClaimsMap.put("email", "email"); + oidcClaimsMap.put("phone", "phone"); + oidcClaimsMap.put("gender", "gender"); + oidcClaimsMap.put("dateOfBirth", "birthdate"); + oidcClaimsMap.put("encodedPhoto", "picture"); + ReflectionTestUtils.setField(authenticationService, "oidcClaimsMapping", oidcClaimsMap); + ReflectionTestUtils.setField(authenticationService, "objectMapper", new ObjectMapper()); + + // Create an IdentityData object + IdentityData identityData = new IdentityData(); + identityData.setDateOfBirth("1987/11/25"); + LanguageValue languageValueName = new LanguageValue(); + languageValueName.setLanguage("eng"); + languageValueName.setValue("Siddharth K Mansour"); + identityData.setName(List.of(languageValueName)); + + // Convert IdentityData to JsonNode + ObjectMapper objectMapper = new ObjectMapper(); + JsonNode identityDataJsonNode = objectMapper.valueToTree(identityData); + + KycExchangeDto kycExchangeRequestDtoV2 = new KycExchangeDto(); + kycExchangeRequestDtoV2.setIndividualId("individualId"); + kycExchangeRequestDtoV2.setTransactionId("transactionId"); + + Map acceptedClaims = new HashMap<>(); + + ObjectNode birthdate = objectMapper.createObjectNode(); + birthdate.put("essential", true); + acceptedClaims.put("birthdate", birthdate); + + ObjectNode gender = objectMapper.createObjectNode(); + gender.put("essential", false); + acceptedClaims.put("gender", gender); + + // Create a list for verified claims + ArrayNode verifiedClaimsList = objectMapper.createArrayNode(); + + // First verified claim with matching trust framework + ObjectNode verifiedClaim1 = objectMapper.createObjectNode(); + ObjectNode verification1 = objectMapper.createObjectNode(); + verification1.put("trust_framework", "pwd"); + verifiedClaim1.put("verification", verification1); + + ObjectNode claims1 = objectMapper.createObjectNode(); + claims1.put("email", NullNode.getInstance()); + claims1.put("birthdate", NullNode.getInstance()); + verifiedClaim1.put("claims", claims1); + verifiedClaimsList.add(verifiedClaim1); + + // Set up the second verified claim that should not match + ObjectNode verifiedClaim2 = objectMapper.createObjectNode(); + ObjectNode verification2 = objectMapper.createObjectNode(); + verification2.put("trust_framework", "non_matching"); + verifiedClaim2.put("verification", verification2); + + ObjectNode claims2 = objectMapper.createObjectNode(); + claims2.put("name", NullNode.getInstance()); + claims2.put("email", NullNode.getInstance()); + claims2.put("gender", NullNode.getInstance()); + verifiedClaim2.put("claims", claims2); + verifiedClaimsList.add(verifiedClaim2); + + // Add the list of verified claims to the outer map + acceptedClaims.put("verified_claims", verifiedClaimsList); + kycExchangeRequestDtoV2.setAcceptedClaimDetail(acceptedClaims); + kycExchangeRequestDtoV2.setClaimLocales(List.of("eng")); + kycExchangeRequestDtoV2.setRequestDateTime(LocalDateTime.now()); + + KycAuth kycAuth = new KycAuth(); + kycAuth.setKycToken("kycToken"); + kycAuth.setTransactionId("transactionId"); + kycAuth.setIndividualId("individualId"); + kycAuth.setPartnerSpecificUserToken("partnerSpecificUserToken"); + kycAuth.setResponseTime(LocalDateTime.now()); + Optional kycAuthOptional = Optional.of(kycAuth); + Mockito.when(authRepository.findByKycTokenAndValidityAndTransactionIdAndIndividualId(Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(kycAuthOptional); + Mockito.when(authRepository.save(Mockito.any())).thenReturn(new KycAuth()); + + // Mock the identityService to return JsonNode + Mockito.when(identityService.getIdentityV2(Mockito.anyString())).thenReturn(identityDataJsonNode); + + VerifiedClaim verifiedClaim = new VerifiedClaim(); + verifiedClaim.setTrustFramework("pwd"); + verifiedClaim.setClaim("email"); + + VerifiedClaim verifiedClaim4 = new VerifiedClaim(); + verifiedClaim4.setTrustFramework("pwd"); + verifiedClaim4.setClaim("birthdate"); + + List verifiedClaimList = new ArrayList<>(); + verifiedClaimList.add(verifiedClaim); + verifiedClaimList.add(verifiedClaim4); + Optional> verifiedClaimsOptional = Optional.of(verifiedClaimList); + + Mockito.when(verifiedClaimRepository.findByIndividualIdAndClaimAndIsActive(Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean())) + .thenReturn(verifiedClaimsOptional); + + JWTSignatureResponseDto jwtSignatureResponseDto = new JWTSignatureResponseDto(); + jwtSignatureResponseDto.setJwtSignedData("jwtSignedData"); + Mockito.when(signatureService.jwtSign(Mockito.any())).thenReturn(jwtSignatureResponseDto); + + KycExchangeResponseDto kycExchangeResponseDto = authenticationService.kycExchange("relyingPartyId", "clientId", kycExchangeRequestDtoV2); + Assert.assertEquals("jwtSignedData", kycExchangeResponseDto.getKyc()); + } + @Test public void kycExchangeV2_withOutVerifiedClaims_thenPass() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException { Map oidcClaimsMap=new HashMap<>(); diff --git a/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/IdentityServiceTest.java b/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/IdentityServiceTest.java index 48200ecd..92cdf8e1 100644 --- a/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/IdentityServiceTest.java +++ b/mock-identity-system/src/test/java/io/mosip/esignet/mock/identitysystem/service/impl/IdentityServiceTest.java @@ -87,6 +87,63 @@ public void addVerifiedClaim_withValidDetails_thenPass() { identityService.addVerifiedClaim(verifiedClaimRequestDto); } + @Test + public void addVerifiedClaim_withInvalidClaim_thenFail() { + + VerifiedClaimRequestDto verifiedClaimRequestDto = new VerifiedClaimRequestDto(); + verifiedClaimRequestDto.setActive(true); + verifiedClaimRequestDto.setIndividualId("123456"); + Map verificationDetail = new HashMap<>(); + + ObjectNode emailVerification = objectMapper.createObjectNode(); + emailVerification.put("trust_framework", "trust_framework"); + verificationDetail.put("null", emailVerification); + verifiedClaimRequestDto.setVerificationDetail(verificationDetail); + + IdentityData identityData = new IdentityData(); + identityData.setEmail("email@gmail.com"); + identityData.setEncodedPhoto("encodedPhoto"); + + MockIdentity mockIdentity = new MockIdentity(); + mockIdentity.setIndividualId("123456"); + mockIdentity.setIdentityJson("{\"individualId\":\"8267411571\",\"pin\":\"111111\",\"fullName\":[{\"language\":\"fra\",\"value\":\"Siddharth K Mansour\"},{\"language\":\"ara\",\"value\":\"تتگلدكنسَزقهِقِفل دسييسيكدكنوڤو\"},{\"language\":\"eng\",\"value\":\"Siddharth K Mansour\"}],\"email\":\"siddhartha.km@gmail.com\",\"phone\":\"+919427357934\"}"); + Mockito.when(identityRepository.findById(Mockito.anyString())).thenReturn(Optional.of(mockIdentity)); + try{ + identityService.addVerifiedClaim(verifiedClaimRequestDto); + }catch (MockIdentityException e){ + Assert.assertEquals(ErrorConstants.INVALID_CLAIM,e.getErrorCode()); + } + } + + @Test + public void addVerifiedClaim_withInvalidTrustFramework_thenFail() { + + VerifiedClaimRequestDto verifiedClaimRequestDto = new VerifiedClaimRequestDto(); + verifiedClaimRequestDto.setActive(true); + verifiedClaimRequestDto.setIndividualId("123456"); + Map verificationDetail = new HashMap<>(); + + ObjectNode emailVerification = objectMapper.createObjectNode(); + emailVerification.put("trust_framework", " "); + verificationDetail.put("email", emailVerification); + verifiedClaimRequestDto.setVerificationDetail(verificationDetail); + + IdentityData identityData = new IdentityData(); + identityData.setEmail("email@gmail.com"); + identityData.setEncodedPhoto("encodedPhoto"); + + MockIdentity mockIdentity = new MockIdentity(); + mockIdentity.setIndividualId("123456"); + mockIdentity.setIdentityJson("{\"individualId\":\"8267411571\",\"pin\":\"111111\",\"fullName\":[{\"language\":\"fra\",\"value\":\"Siddharth K Mansour\"},{\"language\":\"ara\",\"value\":\"تتگلدكنسَزقهِقِفل دسييسيكدكنوڤو\"},{\"language\":\"eng\",\"value\":\"Siddharth K Mansour\"}],\"email\":\"siddhartha.km@gmail.com\",\"phone\":\"+919427357934\"}"); + Mockito.when(verifiedClaimRepository.findById(Mockito.anyString())).thenReturn(Optional.empty()); + Mockito.when(identityRepository.findById(Mockito.anyString())).thenReturn(Optional.of(mockIdentity)); + try{ + identityService.addVerifiedClaim(verifiedClaimRequestDto); + }catch (MockIdentityException e){ + Assert.assertEquals(ErrorConstants.INVALID_REQUEST,e.getErrorCode()); + } + } + @Test public void addVerifiedClaim_withInValidIndividualId_thenFail() { VerifiedClaimRequestDto verifiedClaimRequestDto = new VerifiedClaimRequestDto(); @@ -148,6 +205,23 @@ public void getIdentity_withValidDetails_thenPass() throws MockIdentityException assertEquals(identityData.getIndividualId(), result.getIndividualId()); } + @Test + public void getIdentity_withInValidIdentityJson_thenFail() throws MockIdentityException, JsonProcessingException { + IdentityData identityData = new IdentityData(); + identityData.setEmail("email@gmail.com"); + identityData.setEncodedPhoto("encodedPhoto"); + MockIdentity mockIdentity = new MockIdentity(); + mockIdentity.setIndividualId("123456"); + mockIdentity.setIdentityJson("{ \\\"name\\\": \\\"John Doe, \\\"age\\\": 30 }"); + when(identityRepository.findById(identityData.getIndividualId())).thenReturn(Optional.of(mockIdentity)); + try { + identityService.getIdentity(identityData.getIndividualId()); + Assert.fail(); + }catch (MockIdentityException e){ + Assert.assertEquals(ErrorConstants.JSON_PROCESSING_ERROR,e.getErrorCode()); + } + } + @Test public void getIdentity_withInvalidId_thenFail() { IdentityData identityData = new IdentityData(); @@ -173,6 +247,23 @@ public void updateIdentity_withExistingIndividualId_thenPass() { Assert.assertNotNull(mockIdentity.getIdentityJson()); } + @Test + public void updateIdentity_withInvalidIdentityJson_thenFail() { + IdentityData identityData = new IdentityData(); + identityData.setIndividualId("existing-id"); + identityData.setPassword("new-password"); + MockIdentity mockIdentity = new MockIdentity(); + mockIdentity.setIndividualId("existing-id"); + mockIdentity.setIdentityJson("{ \\\"name\\\": \\\"John Doe, \\\"age\\\": 30 }"); + when(identityRepository.findById("existing-id")).thenReturn(Optional.of(mockIdentity)); + try { + identityService.updateIdentity(identityData); + Assert.fail(); + }catch (MockIdentityException e){ + Assert.assertEquals(ErrorConstants.JSON_PROCESSING_ERROR,e.getErrorCode()); + } + } + @Test public void updateIdentity_withNonExistingIndividualId_thenFail() { IdentityData identityData = new IdentityData();