src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ProjectUtil { public static String formatMessage(String exceptionMsg, Object... fieldValue) { return MessageFormat.format(exceptionMsg, fieldValue); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testFormatMessageSuccess() { String msg = ProjectUtil.formatMessage("Hello {0}", "user"); assertEquals("Hello user", msg); }
@Test public void testFormatMessageFailureWithInvalidVariable() { String msg = ProjectUtil.formatMessage("Hello ", "user"); assertNotEquals("Hello user", msg); } |
ProjectUtil { public static boolean isEmailvalid(final String email) { if (StringUtils.isBlank(email)) { return false; } Matcher matcher = pattern.matcher(email); return matcher.matches(); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testIsEmailValidFailureWithWrongEmail() { boolean msg = ProjectUtil.isEmailvalid("Hello "); assertFalse(msg); }
@Test public void testIsEmailValidFailureWithInvalidFormat() { boolean bool = ProjectUtil.isEmailvalid("amit.kumartarento.com"); Assert.assertFalse(bool); }
@Test public void testIsEmailValidSuccess() { boolean bool = ProjectUtil.isEmailvalid("[email protected]"); assertTrue(bool); } |
ProjectUtil { public static boolean isDateValidFormat(String format, String value) { Date date = null; try { SimpleDateFormat sdf = new SimpleDateFormat(format); date = sdf.parse(value); if (!value.equals(sdf.format(date))) { date = null; } } catch (ParseException ex) { ProjectLogger.log(ex.getMessage(), ex); } return date != null; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testIsDateValidFormatSuccess() { boolean bool = ProjectUtil.isDateValidFormat("yyyy-MM-dd", "2017-12-18"); assertTrue(bool); }
@Test public void testIsDateValidFormatFailureWithEmptyDate() { boolean bool = ProjectUtil.isDateValidFormat("yyyy-MM-dd", ""); assertFalse(bool); }
@Test public void testIsDateValidFormatFailureWithInvalidDate() { boolean bool = ProjectUtil.isDateValidFormat("yyyy-MM-dd", "2017-12-18"); assertTrue(bool); }
@Test public void testIsDateValidFormatFailureWithEmptyDateTime() { boolean bool = ProjectUtil.isDateValidFormat("yyyy-MM-dd HH:mm:ss:SSSZ", ""); assertFalse(bool); } |
ProjectUtil { private static Object getValue(Map<String, Object> map, String key) { Object value = map.get(key); map.remove(key); return value; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testUserRoleSuccess() { assertEquals("PUBLIC", ProjectUtil.UserRole.PUBLIC.getValue()); assertEquals("CONTENT_CREATOR", ProjectUtil.UserRole.CONTENT_CREATOR.getValue()); assertEquals("CONTENT_REVIEWER", ProjectUtil.UserRole.CONTENT_REVIEWER.getValue()); assertEquals("ORG_ADMIN", ProjectUtil.UserRole.ORG_ADMIN.getValue()); assertEquals("ORG_MEMBER", ProjectUtil.UserRole.ORG_MEMBER.getValue()); }
@Test public void testReportTrackingStatusSuccess() { assertEquals(0, ProjectUtil.ReportTrackingStatus.NEW.getValue()); assertEquals(1, ProjectUtil.ReportTrackingStatus.GENERATING_DATA.getValue()); assertEquals(2, ProjectUtil.ReportTrackingStatus.UPLOADING_FILE.getValue()); assertEquals(3, ProjectUtil.ReportTrackingStatus.UPLOADING_FILE_SUCCESS.getValue()); assertEquals(4, ProjectUtil.ReportTrackingStatus.SENDING_MAIL.getValue()); assertEquals(5, ProjectUtil.ReportTrackingStatus.SENDING_MAIL_SUCCESS.getValue()); assertEquals(9, ProjectUtil.ReportTrackingStatus.FAILED.getValue()); }
@Test public void testBulkProcessStatusSuccess() { assertEquals(0, ProjectUtil.BulkProcessStatus.NEW.getValue()); assertEquals(1, ProjectUtil.BulkProcessStatus.IN_PROGRESS.getValue()); assertEquals(2, ProjectUtil.BulkProcessStatus.INTERRUPT.getValue()); assertEquals(3, ProjectUtil.BulkProcessStatus.COMPLETED.getValue()); assertEquals(9, ProjectUtil.BulkProcessStatus.FAILED.getValue()); }
@Test public void testOrgStatusSuccess() { assertEquals(new Integer(0), ProjectUtil.OrgStatus.INACTIVE.getValue()); assertEquals(new Integer(1), ProjectUtil.OrgStatus.ACTIVE.getValue()); assertEquals(new Integer(2), ProjectUtil.OrgStatus.BLOCKED.getValue()); assertEquals(new Integer(3), ProjectUtil.OrgStatus.RETIRED.getValue()); }
@Test public void testProgressStatusSuccess() { assertEquals(0, ProjectUtil.ProgressStatus.NOT_STARTED.getValue()); assertEquals(1, ProjectUtil.ProgressStatus.STARTED.getValue()); assertEquals(2, ProjectUtil.ProgressStatus.COMPLETED.getValue()); }
@Test public void testEnvironmentSuccess() { assertEquals(1, ProjectUtil.Environment.dev.getValue()); assertEquals(2, ProjectUtil.Environment.qa.getValue()); assertEquals(3, ProjectUtil.Environment.prod.getValue()); }
@Test public void testObjectTypesSuccess() { assertEquals("batch", ProjectUtil.ObjectTypes.batch.getValue()); assertEquals("user", ProjectUtil.ObjectTypes.user.getValue()); assertEquals("organisation", ProjectUtil.ObjectTypes.organisation.getValue()); }
@Test public void testSourceSuccess() { assertEquals("web", ProjectUtil.Source.WEB.getValue()); assertEquals("android", ProjectUtil.Source.ANDROID.getValue()); assertEquals("ios", ProjectUtil.Source.IOS.getValue()); }
@Test public void testStatusSuccess() { assertEquals(1, ProjectUtil.Status.ACTIVE.getValue()); assertEquals(0, ProjectUtil.Status.INACTIVE.getValue()); assertEquals(false, ProjectUtil.ActiveStatus.INACTIVE.getValue()); assertEquals(true, ProjectUtil.ActiveStatus.ACTIVE.getValue()); assertEquals("orgimg", ProjectUtil.AzureContainer.orgImage.getName()); assertEquals("userprofileimg", ProjectUtil.AzureContainer.userProfileImg.getName()); }
@Test public void testMigrateActionAcceptValueFailure() { Assert.assertNotEquals("ok", ProjectUtil.MigrateAction.ACCEPT.getValue()); }
@Test public void testMigrateActionRejectValueFailure() { Assert.assertNotEquals("no", ProjectUtil.MigrateAction.REJECT.getValue()); }
@Test public void testMigrateActionAcceptValueSuccess() { Assert.assertEquals("accept", ProjectUtil.MigrateAction.ACCEPT.getValue()); }
@Test public void testMigrateActionRejectValueSuccess() { Assert.assertEquals("reject", ProjectUtil.MigrateAction.REJECT.getValue()); } |
ProjectUtil { public static Map<String, String> getEkstepHeader() { Map<String, String> headerMap = new HashMap<>(); String header = System.getenv(JsonKey.EKSTEP_AUTHORIZATION); if (StringUtils.isBlank(header)) { header = PropertiesCache.getInstance().getProperty(JsonKey.EKSTEP_AUTHORIZATION); } else { header = JsonKey.BEARER + header; } headerMap.put(JsonKey.AUTHORIZATION, header); headerMap.put("Content-Type", "application/json"); return headerMap; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testGetEkstepHeaderSuccess() { Map<String, String> map = ProjectUtil.getEkstepHeader(); assertEquals(map.get("Content-Type"), "application/json"); assertNotNull(map.get(JsonKey.AUTHORIZATION)); } |
UserUtil { public static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest( List<Map<String, String>> externalIds, Map<String, Object> requestMap) { List<UserDeclareEntity> selfDeclaredFieldsList = new ArrayList<>(); if (CollectionUtils.isNotEmpty(externalIds)) { String currOrgId = updateAddOrEditDeclaredFieldsAndGetOrg(externalIds, selfDeclaredFieldsList, requestMap); UserDeclareEntity removeDeclareFields = getRemoveDeclaredFields(externalIds, currOrgId, requestMap); if (null != removeDeclareFields) { selfDeclaredFieldsList.add(removeDeclareFields); } } return selfDeclaredFieldsList; } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testTransformExternalIdsToSelfDeclaredRequest() { beforeEachTest(); List<Map<String, String>> externalIds = getExternalIds(); Map<String, Object> requestMap = new HashMap<>(); requestMap.put(JsonKey.USER_ID, "user1"); requestMap.put(JsonKey.CREATED_BY, "user1"); List<UserDeclareEntity> userDeclareEntityList = UserUtil.transformExternalIdsToSelfDeclaredRequest(externalIds, requestMap); Assert.assertEquals("add", userDeclareEntityList.get(0).getOperation()); } |
ProjectUtil { public static void createAndThrowServerError() { throw new ProjectCommonException( ResponseCode.SERVER_ERROR.getErrorCode(), ResponseCode.SERVER_ERROR.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testCreateAndThrowServerErrorSuccess() { try { ProjectUtil.createAndThrowServerError(); } catch (ProjectCommonException e) { assertEquals(ResponseCode.SERVER_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.SERVER_ERROR.getErrorCode(), e.getCode()); } } |
ProjectUtil { public static void createAndThrowInvalidUserDataException() { throw new ProjectCommonException( ResponseCode.invalidUsrData.getErrorCode(), ResponseCode.invalidUsrData.getErrorMessage(), ResponseCode.CLIENT_ERROR.getResponseCode()); } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testCreateAndThrowInvalidUserDataExceptionSuccess() { try { ProjectUtil.createAndThrowInvalidUserDataException(); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); } } |
UserUtil { public static Map<String, String> fetchOrgIdByProvider( List<String> providers, RequestContext context) { Map<String, String> providerOrgMap = new HashMap<>(); if (CollectionUtils.isNotEmpty(providers)) { try { Map<String, Object> searchQueryMap = new HashMap<>(); Map<String, Object> filters = new HashMap<>(); filters.put(JsonKey.IS_ROOT_ORG, true); filters.put(JsonKey.CHANNEL, providers); searchQueryMap.put(JsonKey.FILTERS, filters); SearchDTO searchDTO = Util.createSearchDto(searchQueryMap); Future<Map<String, Object>> esOrgResF = esUtil.search(searchDTO, ProjectUtil.EsType.organisation.getTypeName(), context); Map<String, Object> esResOrg = (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(esOrgResF); if (MapUtils.isNotEmpty(esResOrg)) { List<Map<String, Object>> orgList = (List<Map<String, Object>>) esResOrg.get(JsonKey.CONTENT); if (CollectionUtils.isNotEmpty(orgList)) { for (Map<String, Object> org : orgList) { providerOrgMap.put((String) org.get(JsonKey.CHANNEL), (String) org.get(JsonKey.ID)); } } } } catch (Exception ex) { logger.error(context, ex.getMessage(), ex); } } return providerOrgMap; } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testfetchOrgIdByProvider() { beforeEachTest(); List<String> providers = new ArrayList<>(); providers.add("channel004"); Map<String, Object> orgMap = new HashMap<>(); List<Map<String, Object>> orgList = new ArrayList<>(); orgMap.put("id", "1234"); orgMap.put("channel", "channel004"); orgList.add(orgMap); Map<String, Object> contentMap = new HashMap<>(); contentMap.put(JsonKey.CONTENT, orgList); Promise<Map<String, Object>> promise = Futures.promise(); promise.success(contentMap); Future<Map<String, Object>> test = promise.future(); SearchDTO searchDTO = new SearchDTO(); when(Util.createSearchDto(Mockito.anyMap())).thenReturn(searchDTO); when(esService.search(searchDTO, ProjectUtil.EsType.organisation.getTypeName(), null)) .thenReturn(promise.future()); Map<String, String> providerMap = UserUtil.fetchOrgIdByProvider(providers, null); Assert.assertTrue(true); } |
ProjectUtil { public static Map<String, String> getDateRange(int numDays) { Map<String, String> map = new HashMap<>(); if (numDays <= 0) { return map; } Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, -numDays); map.put(STARTDATE, new SimpleDateFormat(YYYY_MM_DD_FORMATTER).format(cal.getTime())); cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, -1); map.put(ENDDATE, new SimpleDateFormat(YYYY_MM_DD_FORMATTER).format(cal.getTime())); return map; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testGetDateRangeSuccess() { int noOfDays = 7; Map<String, String> map = ProjectUtil.getDateRange(noOfDays); Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, -noOfDays); assertEquals(map.get("startDate"), new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime())); cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, -1); assertEquals(map.get("endDate"), new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime())); }
@Test public void testGetDateRangeFailure() { int noOfDays = 14; Map<String, String> map = ProjectUtil.getDateRange(noOfDays); Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, -noOfDays); assertEquals(map.get("startDate"), new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime())); cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); cal.add(Calendar.DATE, noOfDays); assertNotEquals(map.get("endDate"), new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime())); }
@Test public void testGetDateRangeFailureWithZeroDays() { int noOfDays = 0; Map<String, String> map = ProjectUtil.getDateRange(noOfDays); assertNull(map.get("startDate")); assertNull(map.get("endDate")); }
@Test public void testGetDateRangeFailureWithNegativeValue() { int noOfDays = -100; Map<String, String> map = ProjectUtil.getDateRange(noOfDays); assertNull(map.get("startDate")); assertNull(map.get("endDate")); } |
ProjectUtil { public static String getLmsUserId(String fedUserId) { String userId = fedUserId; String prefix = "f:" + getConfigValue(JsonKey.SUNBIRD_KEYCLOAK_USER_FEDERATION_PROVIDER_ID) + ":"; if (StringUtils.isNotBlank(fedUserId) && fedUserId.startsWith(prefix)) { userId = fedUserId.replace(prefix, ""); } return userId; } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testGetLmsUserIdSuccessWithoutFedUserId() { String userid = ProjectUtil.getLmsUserId("1234567890"); assertEquals("1234567890", userid); } |
UserUtil { public static void encryptDeclarationFields( List<Map<String, Object>> declarations, Map<String, Object> userDbRecords, RequestContext context) throws Exception { for (Map<String, Object> declareFields : declarations) { Map<String, Object> userInfoMap = (Map<String, Object>) declareFields.get(JsonKey.INFO); if (MapUtils.isNotEmpty(userInfoMap)) { for (Map.Entry<String, Object> userInfo : userInfoMap.entrySet()) { String key = userInfo.getKey(); String value = (String) userInfo.getValue(); if (JsonKey.DECLARED_EMAIL.equals(key) || JsonKey.DECLARED_PHONE.equals(key)) { if (UserUtility.isMasked(value)) { if (JsonKey.DECLARED_EMAIL.equals(key)) { userInfoMap.put(key, userDbRecords.get(JsonKey.EMAIL)); } else { userInfoMap.put(key, userDbRecords.get(JsonKey.PHONE)); } } else { userInfoMap.put(key, encryptionService.encryptData(value, context)); } } } } } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testEncryptDeclareFields() throws Exception { beforeEachTest(); List<Map<String, Object>> declarations = new ArrayList<>(); Map<String, Object> declareFieldMap = new HashMap<>(); Map<String, Object> userInfo = new HashMap<>(); userInfo.put(JsonKey.DECLARED_EMAIL, "a**.com"); userInfo.put(JsonKey.DECLARED_PHONE, "9****90"); userInfo.put(JsonKey.DECLARED_DISTRICT, "Karnataka"); declareFieldMap.put(JsonKey.INFO, userInfo); declarations.add(declareFieldMap); Map<String, Object> dbRecords = new HashMap<>(); RequestContext context = new RequestContext(); try { UserUtil.encryptDeclarationFields(declarations, dbRecords, context); } catch (Exception ex) { } Assert.assertTrue(true); } |
ProjectUtil { public static boolean validateCountryCode(String countryCode) { String pattern = "^(?:[+] ?){0,1}(?:[0-9] ?){1,3}"; try { Pattern patt = Pattern.compile(pattern); Matcher matcher = patt.matcher(countryCode); return matcher.matches(); } catch (RuntimeException e) { return false; } } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testValidateCountryCode() { boolean isValid = ProjectUtil.validateCountryCode("+91"); assertTrue(isValid); isValid = ProjectUtil.validateCountryCode("9a"); assertFalse(isValid); } |
ProjectUtil { public static boolean validateUUID(String uuidStr) { try { UUID.fromString(uuidStr); return true; } catch (Exception ex) { return false; } } static String getFormattedDate(); static boolean isEmailvalid(final String email); static String createAuthToken(String name, String source); static String getUniqueIdFromTimestamp(int environmentId); static synchronized String generateUniqueId(); static boolean isNull(Object obj); static boolean isNotNull(Object obj); static String formatMessage(String exceptionMsg, Object... fieldValue); static SimpleDateFormat getDateFormatter(); static VelocityContext getContext(Map<String, Object> map); static Map<String, Object> createCheckResponse(
String serviceName, boolean isError, Exception e); static String registertag(
String tagId, String body, Map<String, String> header, RequestContext context); static String generateRandomPassword(); static boolean validatePhoneNumber(String phone); static Map<String, String> getEkstepHeader(); static boolean validatePhone(String phNumber, String countryCode); static boolean validateCountryCode(String countryCode); static boolean validateUUID(String uuidStr); static String getSMSBody(Map<String, String> smsTemplate); static boolean isDateValidFormat(String format, String value); static void createAndThrowServerError(); static ProjectCommonException createServerError(ResponseCode responseCode); static void createAndThrowInvalidUserDataException(); static boolean isUrlvalid(String url); static String getConfigValue(String key); static boolean isNotEmptyStringArray(String[] strArray); static String convertMapToJsonString(List<Map<String, Object>> mapList); static void removeUnwantedFields(Map<String, Object> map, String... keys); static T convertToRequestPojo(Request request, Class<T> clazz); static Map<String, String> getDateRange(int numDays); static ProjectCommonException createClientException(ResponseCode responseCode); static String getLmsUserId(String fedUserId); static String getFirstNCharacterString(String originalText, int noOfChar); static final String YEAR_MONTH_DATE_FORMAT; static PropertiesCache propertiesCache; static final String[] excludes; } | @Test public void testValidateUUID() { boolean isValid = ProjectUtil.validateUUID("1df03f56-ceba-4f2d-892c-2b1609e7b05f"); assertTrue(isValid); } |
HttpClientUtil { public static String get(String requestURL, Map<String, String> headers) { CloseableHttpResponse response = null; try { HttpGet httpGet = new HttpGet(requestURL); if (MapUtils.isNotEmpty(headers)) { for (Map.Entry<String, String> entry : headers.entrySet()) { httpGet.addHeader(entry.getKey(), entry.getValue()); } } response = httpclient.execute(httpGet); int status = response.getStatusLine().getStatusCode(); if (status >= 200 && status < 300) { HttpEntity httpEntity = response.getEntity(); byte[] bytes = EntityUtils.toByteArray(httpEntity); StatusLine sl = response.getStatusLine(); ProjectLogger.log( "Response from get call : " + sl.getStatusCode() + " - " + sl.getReasonPhrase(), LoggerEnum.INFO.name()); return new String(bytes); } else { return ""; } } catch (Exception ex) { ProjectLogger.log("Exception occurred while calling get method", ex); return ""; } finally { if (null != response) { try { response.close(); } catch (Exception ex) { ProjectLogger.log("Exception occurred while closing get response object", ex); } } } } private HttpClientUtil(); static HttpClientUtil getInstance(); static String get(String requestURL, Map<String, String> headers); static String post(String requestURL, String params, Map<String, String> headers); static String postFormData(
String requestURL, Map<String, String> params, Map<String, String> headers); static String patch(String requestURL, String params, Map<String, String> headers); } | @Test public void testGetSuccess() throws IOException { CloseableHttpResponse response = PowerMockito.mock(CloseableHttpResponse.class); StatusLine statusLine = PowerMockito.mock(StatusLine.class); PowerMockito.when(response.getStatusLine()).thenReturn(statusLine); PowerMockito.when(statusLine.getStatusCode()).thenReturn(200); HttpEntity entity = PowerMockito.mock(HttpEntity.class); PowerMockito.when(response.getEntity()).thenReturn(entity); PowerMockito.mockStatic(EntityUtils.class); byte[] bytes = "{\"message\":\"success\"}".getBytes(); PowerMockito.when(EntityUtils.toByteArray(Mockito.any(HttpEntity.class))).thenReturn(bytes); PowerMockito.when(httpclient.execute(Mockito.any(HttpGet.class))).thenReturn(response); String res = HttpClientUtil.get("http: assertTrue("{\"message\":\"success\"}".equals(res)); } |
HttpClientUtil { public static String post(String requestURL, String params, Map<String, String> headers) { CloseableHttpResponse response = null; try { HttpPost httpPost = new HttpPost(requestURL); if (MapUtils.isNotEmpty(headers)) { for (Map.Entry<String, String> entry : headers.entrySet()) { httpPost.addHeader(entry.getKey(), entry.getValue()); } } StringEntity entity = new StringEntity(params); httpPost.setEntity(entity); response = httpclient.execute(httpPost); int status = response.getStatusLine().getStatusCode(); if (status >= 200 && status < 300) { HttpEntity httpEntity = response.getEntity(); byte[] bytes = EntityUtils.toByteArray(httpEntity); StatusLine sl = response.getStatusLine(); ProjectLogger.log( "Response from post call : " + sl.getStatusCode() + " - " + sl.getReasonPhrase(), LoggerEnum.INFO.name()); return new String(bytes); } else { return ""; } } catch (Exception ex) { ProjectLogger.log("Exception occurred while calling Post method", ex); return ""; } finally { if (null != response) { try { response.close(); } catch (Exception ex) { ProjectLogger.log("Exception occurred while closing Post response object", ex); } } } } private HttpClientUtil(); static HttpClientUtil getInstance(); static String get(String requestURL, Map<String, String> headers); static String post(String requestURL, String params, Map<String, String> headers); static String postFormData(
String requestURL, Map<String, String> params, Map<String, String> headers); static String patch(String requestURL, String params, Map<String, String> headers); } | @Test public void testPostSuccess() throws IOException { CloseableHttpResponse response = PowerMockito.mock(CloseableHttpResponse.class); StatusLine statusLine = PowerMockito.mock(StatusLine.class); PowerMockito.when(response.getStatusLine()).thenReturn(statusLine); PowerMockito.when(statusLine.getStatusCode()).thenReturn(200); HttpEntity entity = PowerMockito.mock(HttpEntity.class); PowerMockito.when(response.getEntity()).thenReturn(entity); PowerMockito.mockStatic(EntityUtils.class); byte[] bytes = "{\"message\":\"success\"}".getBytes(); PowerMockito.when(EntityUtils.toByteArray(Mockito.any(HttpEntity.class))).thenReturn(bytes); PowerMockito.when(httpclient.execute(Mockito.any(HttpPost.class))).thenReturn(response); String res = HttpClientUtil.post("http: assertTrue("{\"message\":\"success\"}".equals(res)); } |
HttpClientUtil { public static String postFormData( String requestURL, Map<String, String> params, Map<String, String> headers) { CloseableHttpResponse response = null; try { HttpPost httpPost = new HttpPost(requestURL); if (MapUtils.isNotEmpty(headers)) { for (Map.Entry<String, String> entry : headers.entrySet()) { httpPost.addHeader(entry.getKey(), entry.getValue()); } } List<NameValuePair> form = new ArrayList<>(); for (Map.Entry<String, String> entry : params.entrySet()) { form.add(new BasicNameValuePair(entry.getKey(), entry.getValue())); } UrlEncodedFormEntity entity = new UrlEncodedFormEntity(form, Consts.UTF_8); httpPost.setEntity(entity); response = httpclient.execute(httpPost); int status = response.getStatusLine().getStatusCode(); if (status >= 200 && status < 300) { HttpEntity httpEntity = response.getEntity(); byte[] bytes = EntityUtils.toByteArray(httpEntity); StatusLine sl = response.getStatusLine(); ProjectLogger.log( "Response from post call : " + sl.getStatusCode() + " - " + sl.getReasonPhrase(), LoggerEnum.INFO.name()); return new String(bytes); } else { return ""; } } catch (Exception ex) { ProjectLogger.log("Exception occurred while calling Post method", ex); return ""; } finally { if (null != response) { try { response.close(); } catch (Exception ex) { ProjectLogger.log("Exception occurred while closing Post response object", ex); } } } } private HttpClientUtil(); static HttpClientUtil getInstance(); static String get(String requestURL, Map<String, String> headers); static String post(String requestURL, String params, Map<String, String> headers); static String postFormData(
String requestURL, Map<String, String> params, Map<String, String> headers); static String patch(String requestURL, String params, Map<String, String> headers); } | @Test public void testPostFormSuccess() throws IOException { CloseableHttpResponse response = PowerMockito.mock(CloseableHttpResponse.class); StatusLine statusLine = PowerMockito.mock(StatusLine.class); PowerMockito.when(response.getStatusLine()).thenReturn(statusLine); PowerMockito.when(statusLine.getStatusCode()).thenReturn(200); HttpEntity entity = PowerMockito.mock(HttpEntity.class); PowerMockito.when(response.getEntity()).thenReturn(entity); PowerMockito.mockStatic(EntityUtils.class); byte[] bytes = "{\"message\":\"success\"}".getBytes(); PowerMockito.when(EntityUtils.toByteArray(Mockito.any(HttpEntity.class))).thenReturn(bytes); PowerMockito.when(httpclient.execute(Mockito.any(HttpPost.class))).thenReturn(response); Map<String,String> fields = new HashMap<>(); fields.put("message", "success"); String res = HttpClientUtil.postFormData("http: assertTrue("{\"message\":\"success\"}".equals(res)); } |
HttpClientUtil { public static String patch(String requestURL, String params, Map<String, String> headers) { CloseableHttpResponse response = null; try { HttpPatch httpPatch = new HttpPatch(requestURL); if (MapUtils.isNotEmpty(headers)) { for (Map.Entry<String, String> entry : headers.entrySet()) { httpPatch.addHeader(entry.getKey(), entry.getValue()); } } StringEntity entity = new StringEntity(params); httpPatch.setEntity(entity); response = httpclient.execute(httpPatch); int status = response.getStatusLine().getStatusCode(); if (status >= 200 && status < 300) { HttpEntity httpEntity = response.getEntity(); byte[] bytes = EntityUtils.toByteArray(httpEntity); StatusLine sl = response.getStatusLine(); ProjectLogger.log( "Response from patch call : " + sl.getStatusCode() + " - " + sl.getReasonPhrase(), LoggerEnum.INFO.name()); return new String(bytes); } else { return ""; } } catch (Exception ex) { ProjectLogger.log("Exception occurred while calling patch method", ex); return ""; } finally { if (null != response) { try { response.close(); } catch (Exception ex) { ProjectLogger.log("Exception occurred while closing patch response object", ex); } } } } private HttpClientUtil(); static HttpClientUtil getInstance(); static String get(String requestURL, Map<String, String> headers); static String post(String requestURL, String params, Map<String, String> headers); static String postFormData(
String requestURL, Map<String, String> params, Map<String, String> headers); static String patch(String requestURL, String params, Map<String, String> headers); } | @Test public void testPatchSuccess() throws IOException { CloseableHttpResponse response = PowerMockito.mock(CloseableHttpResponse.class); StatusLine statusLine = PowerMockito.mock(StatusLine.class); PowerMockito.when(response.getStatusLine()).thenReturn(statusLine); PowerMockito.when(statusLine.getStatusCode()).thenReturn(200); HttpEntity entity = PowerMockito.mock(HttpEntity.class); PowerMockito.when(response.getEntity()).thenReturn(entity); PowerMockito.mockStatic(EntityUtils.class); byte[] bytes = "{\"message\":\"success\"}".getBytes(); PowerMockito.when(EntityUtils.toByteArray(Mockito.any(HttpEntity.class))).thenReturn(bytes); PowerMockito.when(httpclient.execute(Mockito.any(HttpPost.class))).thenReturn(response); String res = HttpClientUtil.patch("http: assertTrue("{\"message\":\"success\"}".equals(res)); } |
Slug { public static String makeSlug(String input, boolean transliterate) { String origInput = input; String tempInputValue = ""; if (input == null) { ProjectLogger.log("Provided input value is null"); return input; } tempInputValue = input.trim(); tempInputValue = urlDecode(tempInputValue); if (transliterate) { String transliterated = transliterate(tempInputValue); tempInputValue = transliterated; } tempInputValue = WHITESPACE.matcher(tempInputValue).replaceAll("-"); tempInputValue = Normalizer.normalize(tempInputValue, Form.NFD); tempInputValue = NONLATIN.matcher(tempInputValue).replaceAll(""); tempInputValue = normalizeDashes(tempInputValue); validateResult(tempInputValue, origInput); return tempInputValue.toLowerCase(Locale.ENGLISH); } static String makeSlug(String input, boolean transliterate); static String transliterate(String input); static String urlDecode(String input); static String removeDuplicateChars(String text); static String normalizeDashes(String text); } | @Test public void createSlugWithNullValue() { String slug = Slug.makeSlug(null, true); Assert.assertEquals(null, slug); }
@Test public void createSlug() { String val = "NTP@#Test"; String slug = Slug.makeSlug(val, true); Assert.assertEquals("ntptest", slug); } |
Slug { public static String removeDuplicateChars(String text) { Set<Character> set = new LinkedHashSet<>(); StringBuilder ret = new StringBuilder(text.length()); if (text.length() == 0) { return ""; } for (int i = 0; i < text.length(); i++) { set.add(text.charAt(i)); } Iterator<Character> itr = set.iterator(); while (itr.hasNext()) { ret.append(itr.next()); } return ret.toString(); } static String makeSlug(String input, boolean transliterate); static String transliterate(String input); static String urlDecode(String input); static String removeDuplicateChars(String text); static String normalizeDashes(String text); } | @Test public void removeDuplicateChar() { String val = Slug.removeDuplicateChars("ntpntest"); Assert.assertEquals("ntpes", val); } |
UserUtil { public static UserDeclareEntity createUserDeclaredObject( Map<String, Object> declareFieldMap, String callerId) { UserDeclareEntity userDeclareEntity = new UserDeclareEntity( (String) declareFieldMap.get(JsonKey.USER_ID), (String) declareFieldMap.get(JsonKey.ORG_ID), (String) declareFieldMap.get(JsonKey.PERSONA), (Map<String, Object>) declareFieldMap.get(JsonKey.INFO)); if (StringUtils.isBlank((String) declareFieldMap.get(JsonKey.OPERATION))) { ProjectCommonException.throwClientErrorException(ResponseCode.invalidOperationName); } userDeclareEntity.setOperation((String) declareFieldMap.get(JsonKey.OPERATION)); if (JsonKey.ADD.equals(userDeclareEntity.getOperation())) { userDeclareEntity.setCreatedBy((String) declareFieldMap.get(JsonKey.CREATED_BY)); } else { userDeclareEntity.setUpdatedBy((String) declareFieldMap.get(JsonKey.UPDATED_BY)); userDeclareEntity.setStatus((String) declareFieldMap.get(JsonKey.STATUS)); } if (StringUtils.isBlank((String) declareFieldMap.get(JsonKey.STATUS))) { userDeclareEntity.setStatus(JsonKey.PENDING); } userDeclareEntity.setErrorType((String) declareFieldMap.get(JsonKey.ERR_TYPE)); return userDeclareEntity; } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testCreateSelfDeclaredObject() { Map<String, Object> declareFieldMap = new HashMap<>(); declareFieldMap.put(JsonKey.USER_ID, "1234"); declareFieldMap.put(JsonKey.ORG_ID, "012345678"); declareFieldMap.put(JsonKey.PERSONA, "teacher"); declareFieldMap.put(JsonKey.OPERATION, "add"); Map<String, Object> userInfo = new HashMap<>(); userInfo.put(JsonKey.DECLARED_EMAIL, "a**.com"); userInfo.put(JsonKey.DECLARED_PHONE, "9****90"); userInfo.put(JsonKey.DECLARED_DISTRICT, "Karnataka"); declareFieldMap.put(JsonKey.INFO, userInfo); UserDeclareEntity userDeclareEntity = UserUtil.createUserDeclaredObject(declareFieldMap, "01245444444"); Assert.assertEquals("PENDING", userDeclareEntity.getStatus()); } |
LogMaskServiceImpl implements DataMaskingService { public String maskEmail(String email) { if (email.indexOf("@") > 4) { return email.replaceAll("(^[^@]{4}|(?!^)\\G)[^@]", "$1*"); } else { return email.replaceAll("(^[^@]{2}|(?!^)\\G)[^@]", "$1*"); } } String maskEmail(String email); String maskPhone(String phone); } | @Test public void maskEmail() { HashMap<String, String> emailMaskExpectations = new HashMap<String, String>() { { put("[email protected]", "ab*@gmail.com"); put("[email protected]", "ab**@yahoo.com"); put("[email protected]", "abcd****@testmail.org"); } }; emailMaskExpectations.forEach( (email, expectedResult) -> { assertEquals(expectedResult, logMaskService.maskEmail(email)); }); }
@Test public void maskEmail() { HashMap<String, String> emailMaskExpectations = new HashMap<String, String>(){ { put("[email protected]", "ab*@gmail.com"); put("[email protected]", "ab**@yahoo.com"); put("[email protected]", "abcd****@testmail.org"); } }; emailMaskExpectations.forEach((email, expectedResult) -> { assertEquals(expectedResult, logMaskService.maskEmail(email)); }); } |
LogMaskServiceImpl implements DataMaskingService { public String maskPhone(String phone) { return phone.replaceAll("(^[^*]{9}|(?!^)\\G)[^*]", "$1*"); } String maskEmail(String email); String maskPhone(String phone); } | @Test public void maskPhone() { HashMap<String, String> phoneMaskExpectations = new HashMap<String, String>() { { put("0123456789", "012345678*"); put("123-456-789", "123-456-7**"); put("123", "123"); } }; phoneMaskExpectations.forEach( (phone, expectedResult) -> { assertEquals(expectedResult, logMaskService.maskPhone(phone)); }); }
@Test public void maskPhone() { HashMap<String, String> phoneMaskExpectations = new HashMap<String, String>(){ { put("0123456789", "012345678*"); put("123-456-789", "123-456-7**"); put("123", "123"); } }; phoneMaskExpectations.forEach((phone, expectedResult) -> { assertEquals(expectedResult, logMaskService.maskPhone(phone)); }); } |
ExcelFileUtil extends FileUtil { @SuppressWarnings({"resource", "unused"}) public File writeToFile(String fileName, List<List<Object>> dataValues) { XSSFWorkbook workbook = new XSSFWorkbook(); XSSFSheet sheet = workbook.createSheet("Data"); FileOutputStream out = null; File file = null; int rownum = 0; for (Object key : dataValues) { Row row = sheet.createRow(rownum); List<Object> objArr = dataValues.get(rownum); int cellnum = 0; for (Object obj : objArr) { Cell cell = row.createCell(cellnum++); if (obj instanceof String) { cell.setCellValue((String) obj); } else if (obj instanceof Integer) { cell.setCellValue((Integer) obj); } else if (obj instanceof List) { cell.setCellValue(getListValue(obj)); } else if (obj instanceof Double) { cell.setCellValue((Double) obj); } else { if (ProjectUtil.isNotNull(obj)) { cell.setCellValue(obj.toString()); } } } rownum++; } try { file = new File(fileName + ".xlsx"); out = new FileOutputStream(file); workbook.write(out); ProjectLogger.log("File " + fileName + " created successfully"); } catch (Exception e) { ProjectLogger.log(e.getMessage(), e); } finally { if (null != out) { try { out.close(); } catch (IOException e) { ProjectLogger.log(e.getMessage(), e); } } } return file; } @SuppressWarnings({"resource", "unused"}) File writeToFile(String fileName, List<List<Object>> dataValues); } | @Test public void testWriteToFile() { String fileName = "test"; List<List<Object>> data = new ArrayList<>(); List<Object> dataObjects = new ArrayList<>(); dataObjects.add("test1"); dataObjects.add(new ArrayList<>()); dataObjects.add(1); dataObjects.add(2.0D); data.add(dataObjects); ExcelFileUtil excelFileUtil = new ExcelFileUtil(); File file = excelFileUtil.writeToFile(fileName, data); String[] expectedFileName = StringUtils.split(file.getName(), '.'); Assert.assertEquals("test", expectedFileName[0]); Assert.assertEquals("xlsx", expectedFileName[1]); } |
CassandraOperationImpl implements CassandraOperation { @Override public Response insertRecord( String keyspaceName, String tableName, Map<String, Object> request, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "Cassandra Service insertRecord method started at ==" + startTime); Response response = new Response(); String query = CassandraUtil.getPreparedStatement(keyspaceName, tableName, request); try { PreparedStatement statement = connectionManager.getSession(keyspaceName).prepare(query); BoundStatement boundStatement = new BoundStatement(statement); Iterator<Object> iterator = request.values().iterator(); Object[] array = new Object[request.keySet().size()]; int i = 0; while (iterator.hasNext()) { array[i++] = iterator.next(); } connectionManager.getSession(keyspaceName).execute(boundStatement.bind(array)); response.put(Constants.RESPONSE, Constants.SUCCESS); } catch (Exception e) { if (e.getMessage().contains(JsonKey.UNKNOWN_IDENTIFIER) || e.getMessage().contains(JsonKey.UNDEFINED_IDENTIFIER)) { logger.error( context, "Exception occurred while inserting record to " + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.invalidPropertyError.getErrorCode(), CassandraUtil.processExceptionForUnknownIdentifier(e), ResponseCode.CLIENT_ERROR.getResponseCode()); } logger.error( context, "Exception occured while inserting record to " + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.dbInsertionError.getErrorCode(), ResponseCode.dbInsertionError.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } finally { logQueryElapseTime("insertRecord", startTime, query, context); } return response; } CassandraOperationImpl(); @Override Response insertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response deleteRecord(
String keyspaceName, String tableName, String identifier, RequestContext context); @Override Response getRecordsByProperty(
String keyspaceName,
String tableName,
String propertyName,
List<Object> propertyValueList,
RequestContext context); @Override Response getRecordsByPropertiesWithFiltering(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
List<String> fields,
boolean allowFilter,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
String id,
List<String> properties,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
List<String> ids,
List<String> properties,
RequestContext context); @Override Response getAllRecords(String keyspaceName, String tableName, RequestContext context); @Override Response getAllRecords(
String keyspaceName, String tableName, List<String> fields, RequestContext context); @Override Response upsertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, String key, RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, Map<String, Object> key, RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
String key,
List<String> fields,
RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> fields,
RequestContext context); @Override Response getRecordWithTTLById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); Response getRecordWithTTLByIdentifier(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); @Override Response batchInsert(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response batchUpdateById(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response performBatchAction(
String keySpaceName,
String tableName,
Map<String, Object> inputData,
RequestContext context); @Override Response batchUpdate(
String keyspaceName,
String tableName,
List<Map<String, Map<String, Object>>> list,
RequestContext context); @Override Response getRecordsByIndexedProperty(
String keyspaceName,
String tableName,
String propertyName,
Object propertyValue,
RequestContext context); @Override void deleteRecord(
String keyspaceName,
String tableName,
Map<String, String> compositeKeyMap,
RequestContext context); @Override boolean deleteRecords(
String keyspaceName, String tableName, List<String> identifierList, RequestContext context); @Override Response getRecordsByCompositeKey(
String keyspaceName,
String tableName,
Map<String, Object> compositeKeyMap,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumns(
String keyspaceName,
String tableName,
List<String> properties,
List<String> ids,
RequestContext context); @Override Response getRecordsByPrimaryKeys(
String keyspaceName,
String tableName,
List<String> primaryKeys,
String primaryKeyColumnName,
RequestContext context); @Override Response insertRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
int ttl,
RequestContext context); @Override Response updateRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
int ttl,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumnsAndTTL(
String keyspaceName,
String tableName,
Map<String, Object> primaryKeys,
List<String> properties,
Map<String, String> ttlPropertiesWithAlias,
RequestContext context); @Override Response batchInsertWithTTL(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
List<Integer> ttls,
RequestContext context); @Override Response getRecordByObjectType(
String keyspace,
String tableName,
String columnName,
String key,
int value,
String objectType,
RequestContext context); @Override Response searchValueInList(
String keyspace, String tableName, String key, String value, RequestContext context); @Override Response searchValueInList(
String keyspace,
String tableName,
String key,
String value,
Map<String, Object> propertyMap,
RequestContext context); } | @Test public void testInsertRecordSuccess() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); when(session.execute(boundStatement.bind(Mockito.any()))).thenReturn(resultSet); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { Response response = cassandraOperation.insertRecord("sunbird", "address1", address, null); assertEquals(ResponseCode.success.getErrorCode(), response.get("response")); } catch (Exception ex) { assertNotNull(ex); } }
@Test public void testInsertRecordFailureDBInsertionError() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); when(session.execute(boundStatement.bind(Mockito.any()))) .thenThrow( new ProjectCommonException( ResponseCode.dbInsertionError.getErrorCode(), ResponseCode.dbInsertionError.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode())); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { cassandraOperation.insertRecord("sunbird", "address1", address, null); } catch (Exception ex) { assertNotNull(ex); } }
@Test public void testInsertRecordFailureUnKnownIdentifierError() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); Exception e = new ProjectCommonException( "Undefined column name xyz", "Undefined column name xyz", ResponseCode.SERVER_ERROR.getResponseCode()); when(session.execute(boundStatement.bind(Mockito.any()))).thenThrow(e); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { cassandraOperation.insertRecord("sunbird", "address1", address, null); } catch (Exception ex) { assertNotNull(ex); } } |
CassandraOperationImpl implements CassandraOperation { @Override public Response updateRecord( String keyspaceName, String tableName, Map<String, Object> request, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "Cassandra Service updateRecord method started at ==" + startTime); Response response = new Response(); String query = CassandraUtil.getUpdateQueryStatement(keyspaceName, tableName, request); try { PreparedStatement statement = connectionManager.getSession(keyspaceName).prepare(query); Object[] array = new Object[request.size()]; int i = 0; String str = ""; int index = query.lastIndexOf(Constants.SET.trim()); str = query.substring(index + 4); str = str.replace(Constants.EQUAL_WITH_QUE_MARK, ""); str = str.replace(Constants.WHERE_ID, ""); str = str.replace(Constants.SEMICOLON, ""); String[] arr = str.split(","); for (String key : arr) { array[i++] = request.get(key.trim()); } array[i] = request.get(Constants.IDENTIFIER); BoundStatement boundStatement = statement.bind(array); connectionManager.getSession(keyspaceName).execute(boundStatement); response.put(Constants.RESPONSE, Constants.SUCCESS); } catch (Exception e) { if (e.getMessage().contains(JsonKey.UNKNOWN_IDENTIFIER)) { logger.error( context, Constants.EXCEPTION_MSG_UPDATE + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.invalidPropertyError.getErrorCode(), CassandraUtil.processExceptionForUnknownIdentifier(e), ResponseCode.CLIENT_ERROR.getResponseCode()); } logger.error(context, Constants.EXCEPTION_MSG_UPDATE + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.dbUpdateError.getErrorCode(), ResponseCode.dbUpdateError.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } finally { logQueryElapseTime("updateRecord", startTime, query, context); } return response; } CassandraOperationImpl(); @Override Response insertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response deleteRecord(
String keyspaceName, String tableName, String identifier, RequestContext context); @Override Response getRecordsByProperty(
String keyspaceName,
String tableName,
String propertyName,
List<Object> propertyValueList,
RequestContext context); @Override Response getRecordsByPropertiesWithFiltering(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
List<String> fields,
boolean allowFilter,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
String id,
List<String> properties,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
List<String> ids,
List<String> properties,
RequestContext context); @Override Response getAllRecords(String keyspaceName, String tableName, RequestContext context); @Override Response getAllRecords(
String keyspaceName, String tableName, List<String> fields, RequestContext context); @Override Response upsertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, String key, RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, Map<String, Object> key, RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
String key,
List<String> fields,
RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> fields,
RequestContext context); @Override Response getRecordWithTTLById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); Response getRecordWithTTLByIdentifier(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); @Override Response batchInsert(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response batchUpdateById(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response performBatchAction(
String keySpaceName,
String tableName,
Map<String, Object> inputData,
RequestContext context); @Override Response batchUpdate(
String keyspaceName,
String tableName,
List<Map<String, Map<String, Object>>> list,
RequestContext context); @Override Response getRecordsByIndexedProperty(
String keyspaceName,
String tableName,
String propertyName,
Object propertyValue,
RequestContext context); @Override void deleteRecord(
String keyspaceName,
String tableName,
Map<String, String> compositeKeyMap,
RequestContext context); @Override boolean deleteRecords(
String keyspaceName, String tableName, List<String> identifierList, RequestContext context); @Override Response getRecordsByCompositeKey(
String keyspaceName,
String tableName,
Map<String, Object> compositeKeyMap,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumns(
String keyspaceName,
String tableName,
List<String> properties,
List<String> ids,
RequestContext context); @Override Response getRecordsByPrimaryKeys(
String keyspaceName,
String tableName,
List<String> primaryKeys,
String primaryKeyColumnName,
RequestContext context); @Override Response insertRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
int ttl,
RequestContext context); @Override Response updateRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
int ttl,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumnsAndTTL(
String keyspaceName,
String tableName,
Map<String, Object> primaryKeys,
List<String> properties,
Map<String, String> ttlPropertiesWithAlias,
RequestContext context); @Override Response batchInsertWithTTL(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
List<Integer> ttls,
RequestContext context); @Override Response getRecordByObjectType(
String keyspace,
String tableName,
String columnName,
String key,
int value,
String objectType,
RequestContext context); @Override Response searchValueInList(
String keyspace, String tableName, String key, String value, RequestContext context); @Override Response searchValueInList(
String keyspace,
String tableName,
String key,
String value,
Map<String, Object> propertyMap,
RequestContext context); } | @Test public void testUpdateRecordSuccess() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); when(session.execute(boundStatement.bind(Mockito.any()))).thenReturn(resultSet); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { Response response = cassandraOperation.updateRecord("sunbird", "address1", address, null); assertEquals(ResponseCode.success.getErrorCode(), response.get("response")); } catch (Exception ex) { assertNotNull(ex); } }
@Test public void testUpdateRecordDBUpdateError() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); when(session.execute(boundStatement.bind(Mockito.any()))) .thenThrow( new ProjectCommonException( ResponseCode.dbUpdateError.getErrorCode(), ResponseCode.dbUpdateError.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode())); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { cassandraOperation.updateRecord("sunbird", "address1", address, null); } catch (Exception ex) { assertNotNull(ex); } }
@Test public void testUpdateRecordFailureUnKnownIdentifierError() throws Exception { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); Map<String, Object> address = new HashMap<>(); address.put("id", "1234567890"); address.put("addrLine1", "Line 1"); address.put("addrLine2", "Line 2"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); PreparedStatement statement = PowerMockito.mock(PreparedStatement.class); when(session.prepare(Mockito.anyString())).thenReturn(statement); BoundStatement boundStatement = PowerMockito.mock(BoundStatement.class); PowerMockito.whenNew(BoundStatement.class).withAnyArguments().thenReturn(boundStatement); when(statement.bind()).thenReturn(boundStatement); session.execute(Mockito.any(BoundStatement.class)); Exception e = new ProjectCommonException( "Undefined column name xyz", "Undefined column name xyz", ResponseCode.SERVER_ERROR.getResponseCode()); when(session.execute(boundStatement.bind(Mockito.any()))).thenThrow(e); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { cassandraOperation.updateRecord("sunbird", "address1", address, null); } catch (Exception ex) { assertNotNull(ex); } } |
CassandraOperationImpl implements CassandraOperation { @Override public Response deleteRecord( String keyspaceName, String tableName, String identifier, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "Cassandra Service deleteRecord method started at ==" + startTime); Response response = new Response(); Delete.Where delete = null; try { delete = QueryBuilder.delete() .from(keyspaceName, tableName) .where(eq(Constants.IDENTIFIER, identifier)); connectionManager.getSession(keyspaceName).execute(delete); response.put(Constants.RESPONSE, Constants.SUCCESS); } catch (Exception e) { logger.error(context, Constants.EXCEPTION_MSG_DELETE + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.SERVER_ERROR.getErrorCode(), ResponseCode.SERVER_ERROR.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } finally { if (null != delete) { logQueryElapseTime("deleteRecord", startTime, delete.getQueryString(), context); } } return response; } CassandraOperationImpl(); @Override Response insertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response deleteRecord(
String keyspaceName, String tableName, String identifier, RequestContext context); @Override Response getRecordsByProperty(
String keyspaceName,
String tableName,
String propertyName,
List<Object> propertyValueList,
RequestContext context); @Override Response getRecordsByPropertiesWithFiltering(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
List<String> fields,
boolean allowFilter,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
String id,
List<String> properties,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
List<String> ids,
List<String> properties,
RequestContext context); @Override Response getAllRecords(String keyspaceName, String tableName, RequestContext context); @Override Response getAllRecords(
String keyspaceName, String tableName, List<String> fields, RequestContext context); @Override Response upsertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, String key, RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, Map<String, Object> key, RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
String key,
List<String> fields,
RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> fields,
RequestContext context); @Override Response getRecordWithTTLById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); Response getRecordWithTTLByIdentifier(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); @Override Response batchInsert(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response batchUpdateById(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response performBatchAction(
String keySpaceName,
String tableName,
Map<String, Object> inputData,
RequestContext context); @Override Response batchUpdate(
String keyspaceName,
String tableName,
List<Map<String, Map<String, Object>>> list,
RequestContext context); @Override Response getRecordsByIndexedProperty(
String keyspaceName,
String tableName,
String propertyName,
Object propertyValue,
RequestContext context); @Override void deleteRecord(
String keyspaceName,
String tableName,
Map<String, String> compositeKeyMap,
RequestContext context); @Override boolean deleteRecords(
String keyspaceName, String tableName, List<String> identifierList, RequestContext context); @Override Response getRecordsByCompositeKey(
String keyspaceName,
String tableName,
Map<String, Object> compositeKeyMap,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumns(
String keyspaceName,
String tableName,
List<String> properties,
List<String> ids,
RequestContext context); @Override Response getRecordsByPrimaryKeys(
String keyspaceName,
String tableName,
List<String> primaryKeys,
String primaryKeyColumnName,
RequestContext context); @Override Response insertRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
int ttl,
RequestContext context); @Override Response updateRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
int ttl,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumnsAndTTL(
String keyspaceName,
String tableName,
Map<String, Object> primaryKeys,
List<String> properties,
Map<String, String> ttlPropertiesWithAlias,
RequestContext context); @Override Response batchInsertWithTTL(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
List<Integer> ttls,
RequestContext context); @Override Response getRecordByObjectType(
String keyspace,
String tableName,
String columnName,
String key,
int value,
String objectType,
RequestContext context); @Override Response searchValueInList(
String keyspace, String tableName, String key, String value, RequestContext context); @Override Response searchValueInList(
String keyspace,
String tableName,
String key,
String value,
Map<String, Object> propertyMap,
RequestContext context); } | @Test public void testDeleteRecordSuccess() { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); Session session = PowerMockito.mock(Session.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); session.execute(Mockito.any(Delete.Where.class)); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { Response response = cassandraOperation.deleteRecord("sunbird", "address1", "1234567890", null); assertEquals(ResponseCode.success.getErrorCode(), response.get("response")); } catch (Exception ex) { assertNotNull(ex); } }
@Test public void testDeleteRecordError() { PowerMockito.mockStatic(QueryBuilder.class); when(QueryBuilder.delete()) .thenThrow( new ProjectCommonException( ResponseCode.SERVER_ERROR.getErrorCode(), ResponseCode.SERVER_ERROR.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode())); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); try { cassandraOperation.deleteRecord("sunbird", "address1", "123", null); } catch (Exception ex) { assertNotNull(ex); } } |
UserUtil { public static List<Map<String, Object>> getActiveUserOrgDetails( String userId, RequestContext context) { return getUserOrgDetails(false, userId, context); } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testgetUserOrgDetailsDeActive() { beforeEachTest(); Response response1 = new Response(); List<Map<String, Object>> responseList = new ArrayList<>(); Map<String, Object> result = new HashMap<>(); result.put(JsonKey.IS_DELETED, true); result.put(JsonKey.USER_ID, "123-456-789"); responseList.add(result); response1.getResult().put(JsonKey.RESPONSE, responseList); List<String> ids = new ArrayList<>(); ids.add("123-456-789"); when(ServiceFactory.getInstance()).thenReturn(cassandraOperationImpl); when(cassandraOperationImpl.getRecordsByPrimaryKeys( JsonKey.SUNBIRD, "user_organisation", ids, JsonKey.USER_ID, null)) .thenReturn(response1); List<Map<String, Object>> res = UserUtil.getActiveUserOrgDetails("123-456-789", null); Assert.assertNotNull(res); } |
CassandraOperationImpl implements CassandraOperation { @Override public Response getRecordsByProperty( String keyspaceName, String tableName, String propertyName, List<Object> propertyValueList, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "Cassandra Service getRecordsByProperty method started at ==" + startTime); Response response; Statement selectStatement = null; try { Builder selectBuilder = QueryBuilder.select().all(); selectStatement = selectBuilder .from(keyspaceName, tableName) .where(QueryBuilder.in(propertyName, propertyValueList)); ResultSet results = connectionManager.getSession(keyspaceName).execute(selectStatement); response = CassandraUtil.createResponse(results); } catch (Exception e) { logger.error(context, Constants.EXCEPTION_MSG_FETCH + tableName + " : " + e.getMessage(), e); throw new ProjectCommonException( ResponseCode.SERVER_ERROR.getErrorCode(), ResponseCode.SERVER_ERROR.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } finally { if (null != selectStatement) { logQueryElapseTime("getRecordsByProperty", startTime, selectStatement.toString(), context); } } return response; } CassandraOperationImpl(); @Override Response insertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response deleteRecord(
String keyspaceName, String tableName, String identifier, RequestContext context); @Override Response getRecordsByProperty(
String keyspaceName,
String tableName,
String propertyName,
List<Object> propertyValueList,
RequestContext context); @Override Response getRecordsByPropertiesWithFiltering(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
List<String> fields,
boolean allowFilter,
RequestContext context); @Override Response getRecordsByProperties(
String keyspaceName,
String tableName,
Map<String, Object> propertyMap,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
String id,
List<String> properties,
RequestContext context); @Override Response getPropertiesValueById(
String keyspaceName,
String tableName,
List<String> ids,
List<String> properties,
RequestContext context); @Override Response getAllRecords(String keyspaceName, String tableName, RequestContext context); @Override Response getAllRecords(
String keyspaceName, String tableName, List<String> fields, RequestContext context); @Override Response upsertRecord(
String keyspaceName, String tableName, Map<String, Object> request, RequestContext context); @Override Response updateRecord(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, String key, RequestContext context); @Override Response getRecordById(
String keyspaceName, String tableName, Map<String, Object> key, RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
String key,
List<String> fields,
RequestContext context); @Override Response getRecordById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> fields,
RequestContext context); @Override Response getRecordWithTTLById(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); Response getRecordWithTTLByIdentifier(
String keyspaceName,
String tableName,
Map<String, Object> key,
List<String> ttlFields,
List<String> fields,
RequestContext context); @Override Response batchInsert(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response batchUpdateById(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
RequestContext context); @Override Response performBatchAction(
String keySpaceName,
String tableName,
Map<String, Object> inputData,
RequestContext context); @Override Response batchUpdate(
String keyspaceName,
String tableName,
List<Map<String, Map<String, Object>>> list,
RequestContext context); @Override Response getRecordsByIndexedProperty(
String keyspaceName,
String tableName,
String propertyName,
Object propertyValue,
RequestContext context); @Override void deleteRecord(
String keyspaceName,
String tableName,
Map<String, String> compositeKeyMap,
RequestContext context); @Override boolean deleteRecords(
String keyspaceName, String tableName, List<String> identifierList, RequestContext context); @Override Response getRecordsByCompositeKey(
String keyspaceName,
String tableName,
Map<String, Object> compositeKeyMap,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumns(
String keyspaceName,
String tableName,
List<String> properties,
List<String> ids,
RequestContext context); @Override Response getRecordsByPrimaryKeys(
String keyspaceName,
String tableName,
List<String> primaryKeys,
String primaryKeyColumnName,
RequestContext context); @Override Response insertRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
int ttl,
RequestContext context); @Override Response updateRecordWithTTL(
String keyspaceName,
String tableName,
Map<String, Object> request,
Map<String, Object> compositeKey,
int ttl,
RequestContext context); @Override Response getRecordsByIdsWithSpecifiedColumnsAndTTL(
String keyspaceName,
String tableName,
Map<String, Object> primaryKeys,
List<String> properties,
Map<String, String> ttlPropertiesWithAlias,
RequestContext context); @Override Response batchInsertWithTTL(
String keyspaceName,
String tableName,
List<Map<String, Object>> records,
List<Integer> ttls,
RequestContext context); @Override Response getRecordByObjectType(
String keyspace,
String tableName,
String columnName,
String key,
int value,
String objectType,
RequestContext context); @Override Response searchValueInList(
String keyspace, String tableName, String key, String value, RequestContext context); @Override Response searchValueInList(
String keyspace,
String tableName,
String key,
String value,
Map<String, Object> propertyMap,
RequestContext context); } | @Test public void testGetRecordByPropertySuccess() { CassandraConnectionManager connectionManager = PowerMockito.mock(CassandraConnectionManagerImpl.class); PowerMockito.mockStatic(CassandraConnectionMngrFactory.class); List<Object> list = new ArrayList<>(); list.add("123"); list.add("321"); when(CassandraConnectionMngrFactory.getInstance()).thenReturn(connectionManager); PowerMockito.mockStatic(QueryBuilder.class); Select.Builder selectBuilder = PowerMockito.mock(Select.Builder.class); Select.Selection selectSelection = PowerMockito.mock(Select.Selection.class); when(QueryBuilder.select()).thenReturn(selectSelection); when(selectSelection.all()).thenReturn(selectBuilder); Select select = PowerMockito.mock(Select.class); when(selectBuilder.from(Mockito.anyString(), Mockito.anyString())).thenReturn(select); Select.Where selectWhere = PowerMockito.mock(Select.Where.class); when(select.where(QueryBuilder.in(Mockito.anyString(), Mockito.anyList()))) .thenReturn(selectWhere); Session session = PowerMockito.mock(Session.class); ResultSet resultSet = PowerMockito.mock(ResultSet.class); when(connectionManager.getSession(Mockito.anyString())).thenReturn(session); when(session.execute(selectWhere)).thenReturn(resultSet); CassandraOperation cassandraOperation = ServiceFactory.getInstance(); Iterator<Row> rowItr = Mockito.mock(Iterator.class); Mockito.when(resultSet.iterator()).thenReturn(rowItr); PowerMockito.mockStatic(CassandraUtil.class); when(CassandraUtil.createResponse(resultSet)).thenReturn(new Response()); try { cassandraOperation.getRecordsByProperty("sunbird", "address1", JsonKey.ID, list, null); assertTrue(true); } catch (Exception ex) { assertNotNull(ex); } } |
LocationDaoImpl implements LocationDao { public SearchDTO addSortBy(SearchDTO searchDtO) { if (MapUtils.isNotEmpty(searchDtO.getAdditionalProperties()) && searchDtO.getAdditionalProperties().containsKey(JsonKey.FILTERS) && searchDtO.getAdditionalProperties().get(JsonKey.FILTERS) instanceof Map && ((Map<String, Object>) searchDtO.getAdditionalProperties().get(JsonKey.FILTERS)) .containsKey(JsonKey.TYPE)) { if (MapUtils.isEmpty(searchDtO.getSortBy())) { logger.info("search:addSortBy added sort type name attribute."); searchDtO.getSortBy().put(JsonKey.NAME, DEFAULT_SORT_BY); } } return searchDtO; } @Override Response create(Location location, RequestContext context); @Override Response update(Location location, RequestContext context); @Override Response delete(String locationId, RequestContext context); @Override Response search(Map<String, Object> searchQueryMap, RequestContext context); @Override Response read(String locationId, RequestContext context); @Override Response getRecordByProperty(Map<String, Object> queryMap, RequestContext context); SearchDTO addSortBy(SearchDTO searchDtO); } | @Test public void addSortBySuccess() { LocationDaoImpl dao = new LocationDaoImpl(); SearchDTO searchDto = createSearchDtoObj(); searchDto = dao.addSortBy(searchDto); Assert.assertTrue(searchDto.getSortBy().size() == 1); }
@Test public void sortByNotAddedInCaseFilterWontHaveTypeKey() { LocationDaoImpl dao = new LocationDaoImpl(); SearchDTO searchDto = createSearchDtoObj(); ((Map<String, Object>) searchDto.getAdditionalProperties().get(JsonKey.FILTERS)) .remove(JsonKey.TYPE); searchDto = dao.addSortBy(searchDto); Assert.assertTrue(searchDto.getSortBy().size() == 0); }
@Test public void sortByNotAddedInCasePresent() { LocationDaoImpl dao = new LocationDaoImpl(); SearchDTO searchDto = createSearchDtoObj(); searchDto.getSortBy().put("some key", "DESC"); searchDto = dao.addSortBy(searchDto); Assert.assertTrue(searchDto.getSortBy().size() == 1); } |
SystemSettingDaoImpl implements SystemSettingDao { @Override public Response write(SystemSetting systemSetting, RequestContext context) { ObjectMapper mapper = new ObjectMapper(); Map<String, Object> map = mapper.convertValue(systemSetting, Map.class); Response response = cassandraOperation.upsertRecord(KEYSPACE_NAME, TABLE_NAME, map, context); response.put(JsonKey.ID, map.get(JsonKey.ID)); return response; } SystemSettingDaoImpl(CassandraOperation cassandraOperation); @Override Response write(SystemSetting systemSetting, RequestContext context); @Override SystemSetting readById(String id, RequestContext context); @Override SystemSetting readByField(String field, RequestContext context); List<SystemSetting> readAll(RequestContext context); } | @Test public void testSetSystemSettingSuccess() { PowerMockito.when( cassandraOperation.upsertRecord( Mockito.anyString(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(RequestContext.class))) .thenReturn(new Response()); boolean thrown = false; try { SystemSetting systemSetting = new SystemSetting(ROOT_ORG_ID, FIELD, VALUE); Response upsertResp = systemSettingDaoImpl.write(systemSetting, null); Assert.assertNotEquals(null, upsertResp); } catch (Exception e) { thrown = true; } Assert.assertEquals(false, thrown); } |
SystemSettingDaoImpl implements SystemSettingDao { @Override public SystemSetting readByField(String field, RequestContext context) { Response response = cassandraOperation.getRecordsByIndexedProperty( KEYSPACE_NAME, TABLE_NAME, JsonKey.FIELD, field, context); List<Map<String, Object>> list = (List<Map<String, Object>>) response.get(JsonKey.RESPONSE); if (CollectionUtils.isEmpty(list)) { return null; } return getSystemSetting(list); } SystemSettingDaoImpl(CassandraOperation cassandraOperation); @Override Response write(SystemSetting systemSetting, RequestContext context); @Override SystemSetting readById(String id, RequestContext context); @Override SystemSetting readByField(String field, RequestContext context); List<SystemSetting> readAll(RequestContext context); } | @Test public void testReadSystemSettingSuccess() { PowerMockito.when( cassandraOperation.getRecordsByIndexedProperty( Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(RequestContext.class))) .thenReturn(getSystemSettingSuccessResponse(false)); SystemSetting systemSetting = systemSettingDaoImpl.readByField(ROOT_ORG_ID, null); Assert.assertTrue(null != systemSetting); }
@Test public void testReadSystemSettingEmpty() { PowerMockito.when( cassandraOperation.getRecordsByIndexedProperty( Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(), Mockito.any(RequestContext.class))) .thenReturn(getSystemSettingSuccessResponse(true)); SystemSetting systemSetting = systemSettingDaoImpl.readByField(FIELD, null); Assert.assertTrue(null == systemSetting); } |
SystemSettingDaoImpl implements SystemSettingDao { public List<SystemSetting> readAll(RequestContext context) { Response response = cassandraOperation.getAllRecords(KEYSPACE_NAME, TABLE_NAME, context); List<Map<String, Object>> list = (List<Map<String, Object>>) response.get(JsonKey.RESPONSE); List<SystemSetting> systemSettings = new ArrayList<>(); ObjectMapper mapper = new ObjectMapper(); list.forEach( map -> { SystemSetting systemSetting = mapper.convertValue(map, SystemSetting.class); systemSettings.add(systemSetting); }); return systemSettings; } SystemSettingDaoImpl(CassandraOperation cassandraOperation); @Override Response write(SystemSetting systemSetting, RequestContext context); @Override SystemSetting readById(String id, RequestContext context); @Override SystemSetting readByField(String field, RequestContext context); List<SystemSetting> readAll(RequestContext context); } | @Test public void testReadAllSystemSettingsSuccess() { PowerMockito.when( cassandraOperation.getAllRecords( Mockito.anyString(), Mockito.anyString(), Mockito.any(RequestContext.class))) .thenReturn(getSystemSettingSuccessResponse(false)); List<SystemSetting> result = systemSettingDaoImpl.readAll(null); Assert.assertTrue(null != result); }
@Test public void testReadAllSystemSettingsEmpty() { PowerMockito.when( cassandraOperation.getAllRecords( Mockito.anyString(), Mockito.anyString(), Mockito.any(RequestContext.class))) .thenReturn(getSystemSettingSuccessResponse(true)); List<SystemSetting> result = systemSettingDaoImpl.readAll(null); Assert.assertTrue(null != result); } |
UserUtil { public static void updateExternalIdsWithProvider( List<Map<String, String>> dbResExternalIds, RequestContext context) { if (CollectionUtils.isNotEmpty(dbResExternalIds)) { String orgId = dbResExternalIds.get(0).get(JsonKey.PROVIDER); String provider = fetchProviderByOrgId(orgId, context); dbResExternalIds .stream() .forEach( s -> { if (s.get(JsonKey.PROVIDER) != null && s.get(JsonKey.PROVIDER).equals(s.get(JsonKey.ID_TYPE))) { s.put(JsonKey.ID_TYPE, provider); } s.put(JsonKey.PROVIDER, provider); }); } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testupdateExternalIdsWithProvider() { beforeEachTest(); List<String> providers = new ArrayList<>(); providers.add("channel004"); Map<String, Object> orgMap = new HashMap<>(); List<Map<String, Object>> orgList = new ArrayList<>(); orgMap.put("id", "1234"); orgMap.put("channel", "channel004"); orgList.add(orgMap); Map<String, Object> contentMap = new HashMap<>(); contentMap.put(JsonKey.CONTENT, orgList); Promise<Map<String, Object>> promise = Futures.promise(); promise.success(contentMap); Future<Map<String, Object>> test = promise.future(); SearchDTO searchDTO = new SearchDTO(); when(Util.createSearchDto(Mockito.anyMap())).thenReturn(searchDTO); when(esService.search(searchDTO, ProjectUtil.EsType.organisation.getTypeName(), null)) .thenReturn(promise.future()); Map<String, String> externalIds = new HashMap<>(); externalIds.put(JsonKey.PROVIDER, "1234"); externalIds.put(JsonKey.USER_ID, "w131-2323-323-232-3232"); List<Map<String, String>> externalIdList = new ArrayList<>(); externalIdList.add(externalIds); UserUtil.updateExternalIdsWithProvider(externalIdList, null); Assert.assertTrue(true); } |
UserUtil { public static void updateExternalIdsProviderWithOrgId( Map<String, Object> userMap, RequestContext context) { if (MapUtils.isNotEmpty(userMap)) { Set<String> providerSet = new HashSet<>(); List<Map<String, String>> extList = (List<Map<String, String>>) userMap.get(JsonKey.EXTERNAL_IDS); if (CollectionUtils.isNotEmpty(extList)) { for (Map<String, String> extId : extList) { providerSet.add(extId.get(JsonKey.PROVIDER)); } } Map<String, String> orgProviderMap; if (CollectionUtils.isNotEmpty(providerSet) && providerSet.size() == 1) { String channel = providerSet.stream().findFirst().orElse(""); orgProviderMap = new HashMap<>(); if (channel.equalsIgnoreCase((String) userMap.get(JsonKey.CHANNEL))) { orgProviderMap.put(channel, (String) userMap.get(JsonKey.ROOT_ORG_ID)); } else { orgProviderMap = fetchOrgIdByProvider(new ArrayList<>(providerSet), context); } } else { orgProviderMap = fetchOrgIdByProvider(new ArrayList<>(providerSet), context); } if (CollectionUtils.isNotEmpty( (List<Map<String, String>>) userMap.get(JsonKey.EXTERNAL_IDS))) { for (Map<String, String> externalId : (List<Map<String, String>>) userMap.get(JsonKey.EXTERNAL_IDS)) { String orgId = getCaseInsensitiveOrgFromProvider(externalId.get(JsonKey.PROVIDER), orgProviderMap); if (StringUtils.isBlank(orgId)) { ProjectCommonException.throwClientErrorException( ResponseCode.invalidParameterValue, MessageFormat.format( ResponseCode.invalidParameterValue.getErrorMessage(), JsonKey.PROVIDER, externalId.get(JsonKey.PROVIDER))); } if (null != externalId.get(JsonKey.PROVIDER) && null != externalId.get(JsonKey.ID_TYPE) && externalId.get(JsonKey.PROVIDER).equals(externalId.get(JsonKey.ID_TYPE))) { externalId.put(JsonKey.ID_TYPE, orgId); } externalId.put(JsonKey.PROVIDER, orgId); } } } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testupdateExternalIdsProviderWithOrgId() { beforeEachTest(); List<String> providers = new ArrayList<>(); providers.add("channel004"); Map<String, Object> orgMap = new HashMap<>(); List<Map<String, Object>> orgList = new ArrayList<>(); orgMap.put("id", "1234"); orgMap.put("channel", "channel004"); orgList.add(orgMap); Map<String, Object> contentMap = new HashMap<>(); contentMap.put(JsonKey.CONTENT, orgList); Promise<Map<String, Object>> promise = Futures.promise(); promise.success(contentMap); Future<Map<String, Object>> test = promise.future(); SearchDTO searchDTO = new SearchDTO(); when(Util.createSearchDto(Mockito.anyMap())).thenReturn(searchDTO); when(esService.search(searchDTO, ProjectUtil.EsType.organisation.getTypeName(), null)) .thenReturn(promise.future()); Map<String, String> externalIds = new HashMap<>(); externalIds.put(JsonKey.PROVIDER, "channel1004"); externalIds.put(JsonKey.USER_ID, "w131-2323-323-232-3232"); List<Map<String, String>> externalIdList = new ArrayList<>(); externalIdList.add(externalIds); Map<String, Object> userMap = new HashMap<>(); userMap.put(JsonKey.EXTERNAL_IDS, externalIdList); try { UserUtil.updateExternalIdsProviderWithOrgId(userMap, null); } catch (Exception ex) { Assert.assertTrue(true); Assert.assertEquals( "Invalid value provider for parameter channel1004. Please provide a valid value.", ex.getMessage()); } }
@Test public void testUpdateExternalIdsProviderWithOrgId() { beforeEachTest(); List<Map<String, String>> externalIds = new ArrayList<>(); Map<String, String> extId1 = new HashMap<>(); extId1.put(JsonKey.ORIGINAL_ID_TYPE, JsonKey.DECLARED_EMAIL); extId1.put(JsonKey.ORIGINAL_PROVIDER, "0123"); extId1.put(JsonKey.ORIGINAL_EXTERNAL_ID, "[email protected]"); extId1.put(JsonKey.ID_TYPE, JsonKey.DECLARED_EMAIL); extId1.put(JsonKey.PROVIDER, "0123"); extId1.put(JsonKey.EXTERNAL_ID, "[email protected]"); extId1.put(JsonKey.OPERATION, "add"); externalIds.add(extId1); Map<String, Object> requestMap = new HashMap<>(); requestMap.put(JsonKey.USER_ID, "user1"); requestMap.put(JsonKey.CHANNEL, "0123"); requestMap.put(JsonKey.ROOT_ORG_ID, "012345678921"); requestMap.put(JsonKey.EXTERNAL_IDS, externalIds); UserUtil.updateExternalIdsProviderWithOrgId(requestMap, null); Assert.assertTrue(true); }
@Test public void testUpdateExternalIds2ProviderWithOrgId() { beforeEachTest(); List<Map<String, String>> externalIds = new ArrayList<>(); Map<String, String> extId1 = new HashMap<>(); extId1.put(JsonKey.ORIGINAL_ID_TYPE, JsonKey.DECLARED_EMAIL); extId1.put(JsonKey.ORIGINAL_PROVIDER, "0123"); extId1.put(JsonKey.ORIGINAL_EXTERNAL_ID, "[email protected]"); extId1.put(JsonKey.ID_TYPE, JsonKey.DECLARED_EMAIL); extId1.put(JsonKey.PROVIDER, "0123"); extId1.put(JsonKey.EXTERNAL_ID, "[email protected]"); extId1.put(JsonKey.OPERATION, "add"); Map<String, String> extId2 = new HashMap<>(); extId2.put(JsonKey.ORIGINAL_ID_TYPE, JsonKey.DECLARED_EMAIL); extId2.put(JsonKey.ORIGINAL_PROVIDER, "01234"); extId2.put(JsonKey.ORIGINAL_EXTERNAL_ID, "[email protected]"); extId2.put(JsonKey.ID_TYPE, JsonKey.DECLARED_EMAIL); extId2.put(JsonKey.PROVIDER, "01234"); extId2.put(JsonKey.EXTERNAL_ID, "[email protected]"); extId2.put(JsonKey.OPERATION, "add"); externalIds.add(extId1); externalIds.add(extId2); Map<String, Object> requestMap = new HashMap<>(); requestMap.put(JsonKey.USER_ID, "user1"); requestMap.put(JsonKey.CHANNEL, "0123"); requestMap.put(JsonKey.ROOT_ORG_ID, "012345678921"); requestMap.put(JsonKey.EXTERNAL_IDS, externalIds); try { UserUtil.updateExternalIdsProviderWithOrgId(requestMap, null); } catch (Exception ex) { Assert.assertTrue(true); Assert.assertNotNull(ex); } }
@Test public void testUpdateExternalIds3ProviderWithOrgId() { beforeEachTest(); List<Map<String, String>> externalIds = new ArrayList<>(); Map<String, String> extId2 = new HashMap<>(); extId2.put(JsonKey.ORIGINAL_ID_TYPE, JsonKey.DECLARED_EMAIL); extId2.put(JsonKey.ORIGINAL_PROVIDER, "01234"); extId2.put(JsonKey.ORIGINAL_EXTERNAL_ID, "[email protected]"); extId2.put(JsonKey.ID_TYPE, JsonKey.DECLARED_EMAIL); extId2.put(JsonKey.PROVIDER, "01234"); extId2.put(JsonKey.EXTERNAL_ID, "[email protected]"); extId2.put(JsonKey.OPERATION, "add"); externalIds.add(extId2); Map<String, Object> requestMap = new HashMap<>(); requestMap.put(JsonKey.USER_ID, "user1"); requestMap.put(JsonKey.CHANNEL, "0123"); requestMap.put(JsonKey.ROOT_ORG_ID, "012345678921"); requestMap.put(JsonKey.EXTERNAL_IDS, externalIds); try { UserUtil.updateExternalIdsProviderWithOrgId(requestMap, null); } catch (Exception ex) { Assert.assertTrue(true); Assert.assertEquals( "Invalid value provider for parameter 01234. Please provide a valid value.", ex.getMessage()); } } |
UserUtil { public static void addMaskEmailAndMaskPhone(Map<String, Object> userMap) { String phone = (String) userMap.get(JsonKey.PHONE); String email = (String) userMap.get(JsonKey.EMAIL); if (!StringUtils.isBlank(phone)) { userMap.put(JsonKey.MASKED_PHONE, maskingService.maskPhone(phone)); } if (!StringUtils.isBlank(email)) { userMap.put(JsonKey.MASKED_EMAIL, maskingService.maskEmail(email)); } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testAddMaskEmailAndMaskPhone() { Map<String, Object> requestMap = new HashMap<>(); requestMap.put(JsonKey.PHONE, "9999999999"); requestMap.put(JsonKey.EMAIL, "[email protected]"); UserUtil.addMaskEmailAndMaskPhone(requestMap); Assert.assertTrue(true); } |
UserUtil { public static void removeEntryFromUserLookUp( Map<String, Object> userDbMap, List<String> identifiers, RequestContext context) { logger.info( context, "UserUtil:removeEntryFromUserLookUp remove following identifiers from lookUp table " + identifiers); List<Map<String, String>> reqMap = new ArrayList<>(); Map<String, String> deleteLookUp = new HashMap<>(); if (identifiers.contains(JsonKey.EMAIL) && StringUtils.isNotBlank((String) userDbMap.get(JsonKey.EMAIL))) { deleteLookUp.put(JsonKey.TYPE, JsonKey.EMAIL); deleteLookUp.put(JsonKey.VALUE, (String) userDbMap.get(JsonKey.EMAIL)); reqMap.add(deleteLookUp); } if (identifiers.contains(JsonKey.PHONE) && StringUtils.isNotBlank((String) userDbMap.get(JsonKey.PHONE))) { deleteLookUp = new HashMap<>(); deleteLookUp.put(JsonKey.TYPE, JsonKey.PHONE); deleteLookUp.put(JsonKey.VALUE, (String) userDbMap.get(JsonKey.PHONE)); reqMap.add(deleteLookUp); } if (identifiers.contains(JsonKey.USERNAME) && StringUtils.isNotBlank((String) userDbMap.get(JsonKey.USERNAME))) { deleteLookUp = new HashMap<>(); deleteLookUp.put(JsonKey.TYPE, JsonKey.USERNAME.toLowerCase()); deleteLookUp.put(JsonKey.VALUE, (String) userDbMap.get(JsonKey.USERNAME)); logger.info( context, "UserUtil:removeEntryFromUserLookUp before transliterating username: " + (String) userDbMap.get(JsonKey.USERNAME)); reqMap.add(deleteLookUp); } if (CollectionUtils.isNotEmpty(reqMap)) { UserLookUp userLookUp = new UserLookUp(); userLookUp.deleteRecords(reqMap, context); } } private UserUtil(); static void updateExternalIdsProviderWithOrgId(
Map<String, Object> userMap, RequestContext context); static String getCaseInsensitiveOrgFromProvider(
String provider, Map<String, String> providerOrgMap); static Map<String, Object> validateExternalIdsAndReturnActiveUser(
Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserIdFromExternalId(
Map<String, Object> userMap, RequestContext context); static String getUserId(Map<String, Object> userMap, RequestContext context); static void validateUserPhoneEmailAndWebPages(
User user, String operationType, RequestContext context); static String getDecryptedData(String value, RequestContext context); static List<Map<String, String>> copyAndConvertExternalIdsToLower(
List<Map<String, String>> externalIds); static void storeOriginalExternalIdsValue(List<Map<String, String>> externalIds); static void updateExternalIdsWithProvider(
List<Map<String, String>> dbResExternalIds, RequestContext context); static List<Map<String, String>> convertExternalIdsValueToLowerCase(
List<Map<String, String>> externalIds); static boolean updatePassword(Map<String, Object> userMap, RequestContext context); static void addMaskEmailAndMaskPhone(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptUserData(Map<String, Object> userMap); static void setUserDefaultValueForV3(Map<String, Object> userMap, RequestContext context); static String transliterateUserName(String userName); static String generateUniqueString(int length); static void setUserDefaultValue(
Map<String, Object> userMap, String callerId, RequestContext context); static void validateExternalIds(User user, String operationType, RequestContext context); static void validateExternalIdsForUpdateUser(
User user, boolean isCustodianOrg, RequestContext context); static void checkEmailSameOrDiff(
Map<String, Object> userRequestMap, Map<String, Object> userDbRecord); static void validateUserExternalIds(User user, RequestContext context); static List<Map<String, String>> getExternalIds(String userId, RequestContext context); static List<Map<String, Object>> getActiveUserOrgDetails(
String userId, RequestContext context); static List<Map<String, Object>> getAllUserOrgDetails(
String userId, RequestContext context); static void toLower(Map<String, Object> userMap); static Map<String, Object> validateManagedByUser(
String managedBy, RequestContext context); static void validateManagedUserLimit(String managedBy, RequestContext context); static List<UserDeclareEntity> transformExternalIdsToSelfDeclaredRequest(
List<Map<String, String>> externalIds, Map<String, Object> requestMap); static String fetchProviderByOrgId(String orgId, RequestContext context); static Map<String, String> fetchOrgIdByProvider(
List<String> providers, RequestContext context); static void encryptDeclarationFields(
List<Map<String, Object>> declarations,
Map<String, Object> userDbRecords,
RequestContext context); static UserDeclareEntity createUserDeclaredObject(
Map<String, Object> declareFieldMap, String callerId); static void removeEntryFromUserLookUp(
Map<String, Object> userDbMap, List<String> identifiers, RequestContext context); } | @Test public void testRemoveEntryFromUserLookUp() { beforeEachTest(); Map<String, Object> mergeeMap = new HashMap<>(); mergeeMap.put(JsonKey.EMAIL, "someEmail"); mergeeMap.put(JsonKey.PHONE, "somePhone"); mergeeMap.put(JsonKey.USERNAME, "someUsername"); List<String> userLookUpIdentifiers = Stream.of(JsonKey.EMAIL, JsonKey.PHONE, JsonKey.USERNAME).collect(Collectors.toList()); UserUtil.removeEntryFromUserLookUp(mergeeMap, userLookUpIdentifiers, new RequestContext()); Assert.assertTrue(true); } |
UserOrgDaoImpl implements UserOrgDao { @Override public Response updateUserOrg(UserOrg userOrg, RequestContext context) { Map<String, Object> compositeKey = new LinkedHashMap<>(2); Map<String, Object> request = mapper.convertValue(userOrg, Map.class); compositeKey.put(JsonKey.USER_ID, request.remove(JsonKey.USER_ID)); compositeKey.put(JsonKey.ORGANISATION_ID, request.remove(JsonKey.ORGANISATION_ID)); return cassandraOperation.updateRecord( Util.KEY_SPACE_NAME, TABLE_NAME, request, compositeKey, context); } private UserOrgDaoImpl(); static UserOrgDao getInstance(); @Override Response updateUserOrg(UserOrg userOrg, RequestContext context); @Override Response createUserOrg(UserOrg userOrg, RequestContext context); } | @Test public void testupdateUserOrg() { Response response = new Response(); when(ServiceFactory.getInstance()).thenReturn(cassandraOperationImpl); when(cassandraOperationImpl.updateRecord( Mockito.anyString(), Mockito.anyString(), Mockito.anyMap(), Mockito.anyMap(), Mockito.any())) .thenReturn(response); UserOrg userOrg = new UserOrg(); userOrg.setUserId("123-456-789"); userOrg.setOrganisationId("1234567890"); userOrg.setDeleted(true); UserOrgDao userOrgDao = UserOrgDaoImpl.getInstance(); Response res = userOrgDao.updateUserOrg(userOrg, null); Assert.assertNotNull(res); } |
UserConsentActor extends BaseActor { private void updateUserConsent(Request request) { Map<String, Object> consent = (Map<String, Object>) request.getRequest().getOrDefault(JsonKey.CONSENT_BODY, new HashMap<String, Object>()); String userId = (String) consent.getOrDefault(JsonKey.USER_ID, ""); if(StringUtils.isEmpty(userId)){ userId = (String) request.getContext().get(JsonKey.REQUESTED_BY); } String managedFor = (String)request.getContext().get(JsonKey.MANAGED_FOR); if(StringUtils.isNotEmpty(managedFor)){ userId = managedFor; } consent.put(JsonKey.USER_ID,userId); userService.validateUserId(request, null, request.getRequestContext()); Map consentReq = constructConsentRequest(consent, request.getRequestContext()); userConsentService.updateConsent(consentReq, request.getRequestContext()); Response response = new Response(); Map consentResponse = new HashMap<String, Object>(); consentResponse.put(JsonKey.USER_ID, userId); response.put(JsonKey.CONSENT_BODY, consentResponse); response.put(JsonKey.MESSAGE, JsonKey.CONSENT_SUCCESS_MESSAGE); sender().tell(response, self()); Map<String, Object> targetObject = null; List<Map<String, Object>> correlatedObject = new ArrayList<>(); targetObject = TelemetryUtil.generateTargetObject( userId, TelemetryEnvKey.USER, JsonKey.UPDATE, null); TelemetryUtil.telemetryProcessingCall( consent, targetObject, correlatedObject, request.getContext()); } @Override void onReceive(Request request); } | @Test public void updateUserConsentTest() { TestKit probe = new TestKit(system); ActorRef subject = system.actorOf(props); when(cassandraOperation.getRecordsByProperties( Mockito.anyString(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(RequestContext.class))) .thenReturn(getSuccessResponse()); when(cassandraOperation.upsertRecord( Mockito.anyString(), Mockito.anyString(), Mockito.anyMap(), Mockito.any(RequestContext.class))) .thenReturn(getSuccessResponse()); subject.tell(updateUserConsentRequest(), probe.getRef()); Response res = probe.expectMsgClass(duration("10 second"), Response.class); Assert.assertTrue(null != res && res.getResponseCode() == ResponseCode.OK); } |
OrgExternalService { public String getOrgIdFromOrgExternalIdAndProvider( String externalId, String provider, RequestContext context) { Map<String, Object> dbRequestMap = new HashMap<>(); dbRequestMap.put(JsonKey.EXTERNAL_ID, externalId.toLowerCase()); dbRequestMap.put(JsonKey.PROVIDER, provider.toLowerCase()); Response response = getCassandraOperation() .getRecordsByCompositeKey(KEYSPACE_NAME, ORG_EXTERNAL_IDENTITY, dbRequestMap, context); List<Map<String, Object>> orgList = (List<Map<String, Object>>) response.getResult().get(JsonKey.RESPONSE); if (CollectionUtils.isNotEmpty(orgList)) { Map<String, Object> orgExternalMap = orgList.get(0); if (MapUtils.isNotEmpty(orgExternalMap)) { return (String) orgExternalMap.get(JsonKey.ORG_ID); } } return null; } String getOrgIdFromOrgExternalIdAndProvider(
String externalId, String provider, RequestContext context); } | @Test public void testGetOrgIdFromOrgExtIdFailure() { try { Map<String, Object> dbRequestMap = new HashMap<>(); dbRequestMap.put(JsonKey.EXTERNAL_ID, "anyorgextid"); dbRequestMap.put(JsonKey.PROVIDER, "anyprovider"); Response response = new Response(); List<Map<String, Object>> orgList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); orgList.add(map); response.put(JsonKey.RESPONSE, orgList); when(cassandraOperation.getRecordsByCompositeKey( Util.KEY_SPACE_NAME, ORG_EXTERNAL_IDENTITY, dbRequestMap, null)) .thenReturn(response); String resp = orgExternalService.getOrgIdFromOrgExternalIdAndProvider( "anyOrgExtid", "anyprovider", null); Assert.assertEquals(null, resp); } catch (Exception e) { Assert.assertTrue(false); } }
@Test public void testGetOrgIdFromOrgExtIdSuccess() { try { Map<String, Object> dbRequestMap = new HashMap<>(); dbRequestMap.put(JsonKey.EXTERNAL_ID, "orgextid"); dbRequestMap.put(JsonKey.PROVIDER, "provider"); Response response = new Response(); List<Map<String, Object>> orgList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ORG_ID, "anyOrgId"); orgList.add(map); response.put(JsonKey.RESPONSE, orgList); when(cassandraOperation.getRecordsByCompositeKey( Util.KEY_SPACE_NAME, ORG_EXTERNAL_IDENTITY, dbRequestMap, null)) .thenReturn(response); String resp = orgExternalService.getOrgIdFromOrgExternalIdAndProvider("OrgExtid", "provider", null); Assert.assertEquals("anyOrgId", resp); } catch (Exception e) { Assert.assertTrue(false); } } |
AdminUtilHandler { public static AdminUtilRequestPayload prepareAdminUtilPayload(List<AdminUtilRequestData> reqData){ AdminUtilRequestPayload adminUtilsReq = new AdminUtilRequestPayload(); adminUtilsReq.setId(JsonKey.EKSTEP_SIGNING_SIGN_PAYLOAD); adminUtilsReq.setVer(JsonKey.EKSTEP_SIGNING_SIGN_PAYLOAD_VER); adminUtilsReq.setTs(Calendar.getInstance().getTime().getTime()); adminUtilsReq.setParams(new AdminUtilParams()); adminUtilsReq.setRequest(new AdminUtilRequest(reqData)); return adminUtilsReq; } static AdminUtilRequestPayload prepareAdminUtilPayload(List<AdminUtilRequestData> reqData); static Map<String, Object> fetchEncryptedToken(AdminUtilRequestPayload reqObject); } | @Test public void testPrepareAdminUtilPayload(){ List<AdminUtilRequestData> reqData = new ArrayList<AdminUtilRequestData>(); reqData.add(new AdminUtilRequestData("parentId", "childId1")); reqData.add(new AdminUtilRequestData("parentId", "childId2")); AdminUtilRequestPayload payload = AdminUtilHandler.prepareAdminUtilPayload(reqData); assertEquals(2,payload.getRequest().getData().size()); } |
AdminUtilHandler { public static Map<String, Object> fetchEncryptedToken(AdminUtilRequestPayload reqObject){ Map<String, Object> data = null; ObjectMapper mapper = new ObjectMapper(); try { String body = mapper.writeValueAsString(reqObject); ProjectLogger.log( "AdminUtilHandler :: fetchEncryptedToken: request payload" + body, LoggerEnum.DEBUG); Map<String, String> headers = new HashMap<>(); headers.put("Content-Type", "application/json"); String response = HttpClientUtil.post( ProjectUtil.getConfigValue(JsonKey.ADMINUTIL_BASE_URL) + ProjectUtil.getConfigValue(JsonKey.ADMINUTIL_SIGN_ENDPOINT), body, headers); ProjectLogger.log( "AdminUtilHandler :: fetchEncryptedToken: response payload" + response, LoggerEnum.DEBUG); data = mapper.readValue(response, Map.class); if (MapUtils.isNotEmpty(data)) { data = (Map<String, Object>) data.get(JsonKey.RESULT); } } catch (IOException e) { ProjectLogger.log( "AdminUtilHandler:fetchEncryptedToken Exception occurred : " + e.getMessage(), e, null, LoggerEnum.ERROR.name()); throw new ProjectCommonException( ResponseCode.unableToConnectToAdminUtil.getErrorCode(), ResponseCode.unableToConnectToAdminUtil.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } catch (Exception e) { ProjectLogger.log( "AdminUtilHandler:fetchEncryptedToken Exception occurred : " + e.getMessage(), e, null, LoggerEnum.ERROR.name()); throw new ProjectCommonException( ResponseCode.unableToParseData.getErrorCode(), ResponseCode.unableToParseData.getErrorMessage(), ResponseCode.SERVER_ERROR.getResponseCode()); } return data; } static AdminUtilRequestPayload prepareAdminUtilPayload(List<AdminUtilRequestData> reqData); static Map<String, Object> fetchEncryptedToken(AdminUtilRequestPayload reqObject); } | @Test public void testFetchEncryptedToken() throws IOException { List<AdminUtilRequestData> reqData = new ArrayList<AdminUtilRequestData>(); reqData.add(new AdminUtilRequestData("parentId", "childId1")); reqData.add(new AdminUtilRequestData("parentId", "childId2")); when(HttpClientUtil.post(Mockito.anyString(),Mockito.anyString(),Mockito.anyObject())).thenReturn("{\"id\": \"ekstep.api.am.adminutil.sign.payload\",\"ver\": \"1.0\",\"ets\":1591589862198,\"params\": {\"status\": \"successful\",\"err\": null,\"errmsg\": null,\"msgid\": \"\",\"resmsgid\": \"328749cb-45e3-4b26-aea6-b7f4b97d548b\"}, \"result\": {\"data\": [{\"parentId\": \"parentId\", \"sub\":\"childId1\",\"token\":\"encryptedtoken1\"},{\"parentId\": \"parentId\",\"sub\": \"childId2\",\"token\":\"encryptedtoken2\"}]}}"); Map<String, Object> encryptedTokenList = AdminUtilHandler.fetchEncryptedToken(AdminUtilHandler.prepareAdminUtilPayload(reqData)); ArrayList<Map<String, Object>> data = (ArrayList<Map<String, Object>>) encryptedTokenList.get(JsonKey.DATA); for (Object object : data) { Map<String, Object> tempMap = (Map<String, Object>) object; assertNotNull(tempMap.get(JsonKey.TOKEN)); } } |
Util { public static List<Map<String, Object>> getUserOrgDetails(String userId, RequestContext context) { List<Map<String, Object>> userOrgDataList = new ArrayList<>(); List<Map<String, Object>> userOrganisations = new ArrayList<>(); try { List<String> ids = new ArrayList<>(); ids.add(userId); Util.DbInfo orgUsrDbInfo = Util.dbInfoMap.get(JsonKey.USER_ORG_DB); Response result = cassandraOperation.getRecordsByPrimaryKeys( orgUsrDbInfo.getKeySpace(), orgUsrDbInfo.getTableName(), ids, JsonKey.USER_ID, context); List<Map<String, Object>> userOrgList = new ArrayList<>(); userOrgDataList = (List<Map<String, Object>>) result.get(JsonKey.RESPONSE); userOrgDataList .stream() .forEach( (dataMap) -> { if (null != dataMap.get(JsonKey.IS_DELETED) && !((boolean) dataMap.get(JsonKey.IS_DELETED))) { userOrgList.add(dataMap); } }); if (CollectionUtils.isNotEmpty(userOrgList)) { List<String> organisationIds = userOrgList .stream() .map(m -> (String) m.get(JsonKey.ORGANISATION_ID)) .distinct() .collect(Collectors.toList()); List<String> fields = Arrays.asList(JsonKey.ORG_NAME, JsonKey.PARENT_ORG_ID, JsonKey.ID); Future<Map<String, Map<String, Object>>> orgInfoMapF = esService.getEsResultByListOfIds( organisationIds, fields, EsType.organisation.getTypeName(), context); Map<String, Map<String, Object>> orgInfoMap = (Map<String, Map<String, Object>>) ElasticSearchHelper.getResponseFromFuture(orgInfoMapF); for (Map<String, Object> userOrg : userOrgList) { Map<String, Object> esOrgMap = orgInfoMap.get(userOrg.get(JsonKey.ORGANISATION_ID)); esOrgMap.remove(JsonKey.ID); userOrg.putAll(esOrgMap); userOrganisations.add(userOrg); } } } catch (Exception e) { logger.error(e.getMessage(), e); } return userOrganisations; } private Util(); @SuppressWarnings("rawtypes") static boolean checkOrgStatusTransition(Integer currentState, Integer nextState); static void checkCassandraDbConnections(); static String getProperty(String key); @SuppressWarnings("unchecked") static SearchDTO createSearchDto(Map<String, Object> searchQueryMap); static boolean isNull(Object obj); static boolean isNotNull(Object obj); @SuppressWarnings("unchecked") static String getUserNamebyUserId(String userId, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserbyUserId(String userId, RequestContext context); static String getHashTagIdFromOrgId(String orgId, RequestContext context); static String validateRoles(List<String> roleList); static boolean registerChannel(Map<String, Object> req, RequestContext context); static boolean updateChannel(Map<String, Object> req, RequestContext context); static void initializeContext(Request request, String env); static String getSunbirdWebUrlPerTenent(Map<String, Object> userMap); static String getSunbirdLoginUrl(); static Map<String, Object> getOrgDetails(String identifier, RequestContext context); static String encryptData(String value); static List<User> searchUser(Map<String, Object> searchQueryMap, RequestContext context); static String getLoginId(Map<String, Object> userMap); static void registerUserToOrg(Map<String, Object> userMap, RequestContext context); static String getChannel(String rootOrgId, RequestContext context); @SuppressWarnings("unchecked") static void upsertUserOrgData(Map<String, Object> userMap, RequestContext context); @SuppressWarnings("unchecked") static Map<String, Object> getUserDetails(String userId, RequestContext context); static Map<String, Object> getUserDetails(
Map<String, Object> userDetails, Map<String, Object> orgMap, RequestContext context); static void addEmailAndPhone(Map<String, Object> userDetails); static void checkEmailAndPhoneVerified(Map<String, Object> userDetails); static void addMaskEmailAndPhone(Map<String, Object> userMap); static List<Map<String, Object>> getUserOrgDetails(String userId, RequestContext context); static Request sendOnboardingMail(Map<String, Object> emailTemplateMap); static String getUserRequiredActionLink(
Map<String, Object> templateMap, boolean isUrlShortRequired, RequestContext context); static void getUserRequiredActionLink(
Map<String, Object> templateMap, RequestContext context); static void sendSMS(Map<String, Object> userMap); static Request sendResetPassMail(Map<String, Object> emailTemplateMap); static final Map<String, DbInfo> dbInfoMap; static final int DEFAULT_ELASTIC_DATA_LIMIT; static final String KEY_SPACE_NAME; } | @Test public void testGetUserOrgDetails() { Response response = new Response(); List<Map<String, Object>> responseList = new ArrayList<>(); Map<String, Object> result = new HashMap<>(); result.put(JsonKey.IS_DELETED, false); result.put(JsonKey.USER_ID, "123-456-789"); result.put(JsonKey.ORGANISATION_ID, "1234567890"); responseList.add(result); response.getResult().put(JsonKey.RESPONSE, responseList); List<String> ids = new ArrayList<>(); ids.add("123-456-789"); when(ServiceFactory.getInstance()).thenReturn(cassandraOperationImpl); when(cassandraOperationImpl.getRecordsByPrimaryKeys( JsonKey.SUNBIRD, "user_organisation", ids, JsonKey.USER_ID, null)) .thenReturn(response); Promise<Map<String, Object>> promise = Futures.promise(); promise.success(getEsResponseMap()); when(esService.getDataByIdentifier(Mockito.anyString(), Mockito.anyString(), Mockito.any())) .thenReturn(promise.future()); Promise<String> esPromise = Futures.promise(); esPromise.success("success"); Promise<Map<String, Map<String, Object>>> promise2 = Futures.promise(); promise2.success(getEs2ResponseMap()); when(esService.getEsResultByListOfIds( Mockito.anyList(), Mockito.anyList(), Mockito.anyString(), Mockito.any())) .thenReturn(promise2.future()); List<Map<String, Object>> res = Util.getUserOrgDetails("123-456-789", null); Assert.assertNotNull(res); } |
UserUtility { public static Map<String, Object> encryptUserData(Map<String, Object> userMap) throws Exception { return encryptSpecificUserData(userMap, userKeyToEncrypt); } private UserUtility(); static Map<String, Object> encryptUserData(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptSpecificUserData(
Map<String, Object> userMap, List<String> fieldsToEncrypt); static List<Map<String, Object>> encryptUserAddressData(
List<Map<String, Object>> addressList); static Map<String, Object> decryptUserData(Map<String, Object> userMap); static Map<String, Object> decryptSpecificUserData(
Map<String, Object> userMap, List<String> fieldsToDecrypt); static boolean isMasked(String data); static Map<String, Object> decryptUserDataFrmES(Map<String, Object> userMap); static List<Map<String, Object>> decryptUserAddressData(
List<Map<String, Object>> addressList); static Map<String, Object> encryptUserSearchFilterQueryData(Map<String, Object> map); static String encryptData(String data); static String maskEmailOrPhone(String encryptedEmailOrPhone, String type); } | @Test public void encryptSpecificUserDataSuccess() { String email = "[email protected]"; String userName = "test_user"; String city = "Bangalore"; String addressLine1 = "xyz"; Map<String, Object> userMap = new HashMap<String, Object>(); userMap.put(JsonKey.FIRST_NAME, "test user"); userMap.put(JsonKey.EMAIL, email); userMap.put(JsonKey.USER_NAME, userName); List<Map<String, Object>> addressList = new ArrayList<Map<String, Object>>(); Map<String, Object> address = new HashMap<String, Object>(); address.put(JsonKey.COUNTRY, "India"); address.put(JsonKey.CITY, city); address.put(JsonKey.ADDRESS_LINE1, addressLine1); addressList.add(address); userMap.put(JsonKey.ADDRESS, addressList); Map<String, Object> response = null; try { response = UserUtility.encryptUserData(userMap); } catch (Exception e) { e.printStackTrace(); } assertEquals(userMap.get(JsonKey.FIRST_NAME), response.get(JsonKey.FIRST_NAME)); assertNotEquals(email, response.get(JsonKey.EMAIL)); assertNotEquals( "India", ((List<Map<String, Object>>) response.get(JsonKey.ADDRESS)).get(0).get(JsonKey.COUNTRY)); assertNotEquals( addressLine1, ((List<Map<String, Object>>) response.get(JsonKey.ADDRESS)) .get(0) .get(JsonKey.ADDRESS_LINE1)); } |
UserUtility { public static List<Map<String, Object>> encryptUserAddressData( List<Map<String, Object>> addressList) throws Exception { EncryptionService service = ServiceFactory.getEncryptionServiceInstance(null); for (Map<String, Object> map : addressList) { for (String key : addressKeyToEncrypt) { if (map.containsKey(key)) { map.put(key, service.encryptData((String) map.get(key), null)); } } } return addressList; } private UserUtility(); static Map<String, Object> encryptUserData(Map<String, Object> userMap); @SuppressWarnings("unchecked") static Map<String, Object> encryptSpecificUserData(
Map<String, Object> userMap, List<String> fieldsToEncrypt); static List<Map<String, Object>> encryptUserAddressData(
List<Map<String, Object>> addressList); static Map<String, Object> decryptUserData(Map<String, Object> userMap); static Map<String, Object> decryptSpecificUserData(
Map<String, Object> userMap, List<String> fieldsToDecrypt); static boolean isMasked(String data); static Map<String, Object> decryptUserDataFrmES(Map<String, Object> userMap); static List<Map<String, Object>> decryptUserAddressData(
List<Map<String, Object>> addressList); static Map<String, Object> encryptUserSearchFilterQueryData(Map<String, Object> map); static String encryptData(String data); static String maskEmailOrPhone(String encryptedEmailOrPhone, String type); } | @Test public void encryptUserAddressDataSuccess() { String city = "Bangalore"; String addressLine1 = "xyz"; String state = "Karnataka"; List<Map<String, Object>> addressList = new ArrayList<Map<String, Object>>(); Map<String, Object> address = new HashMap<String, Object>(); address.put(JsonKey.COUNTRY, "India"); address.put(JsonKey.CITY, city); address.put(JsonKey.ADDRESS_LINE1, addressLine1); address.put(JsonKey.STATE, state); addressList.add(address); List<Map<String, Object>> response = null; try { response = UserUtility.encryptUserAddressData(addressList); } catch (Exception e) { e.printStackTrace(); } assertNotEquals("India", response.get(0).get(JsonKey.COUNTRY)); assertNotEquals(addressLine1, response.get(0).get(JsonKey.ADDRESS_LINE1)); assertNotEquals(state, response.get(0).get(JsonKey.STATE)); } |
UserFlagUtil { public static int getFlagValue(String userFlagType, boolean flagEnabled) { int decimalValue = 0; if (userFlagType.equals(UserFlagEnum.PHONE_VERIFIED.getUserFlagType()) && flagEnabled) { decimalValue = UserFlagEnum.PHONE_VERIFIED.getUserFlagValue(); } else if (userFlagType.equals(UserFlagEnum.EMAIL_VERIFIED.getUserFlagType()) && flagEnabled) { decimalValue = UserFlagEnum.EMAIL_VERIFIED.getUserFlagValue(); } else if (userFlagType.equals(UserFlagEnum.STATE_VALIDATED.getUserFlagType()) && flagEnabled) { decimalValue = UserFlagEnum.STATE_VALIDATED.getUserFlagValue(); } return decimalValue; } static int getFlagValue(String userFlagType, boolean flagEnabled); static Map<String, Boolean> assignUserFlagValues(int flagsValue); } | @Test public void testGetFlagValue() { Assert.assertEquals( 2, UserFlagUtil.getFlagValue(UserFlagEnum.EMAIL_VERIFIED.getUserFlagType(), true)); Assert.assertEquals( 1, UserFlagUtil.getFlagValue(UserFlagEnum.PHONE_VERIFIED.getUserFlagType(), true)); Assert.assertEquals( 4, UserFlagUtil.getFlagValue(UserFlagEnum.STATE_VALIDATED.getUserFlagType(), true)); } |
UserFlagUtil { public static Map<String, Boolean> assignUserFlagValues(int flagsValue) { Map<String, Boolean> userFlagMap = new HashMap<>(); setDefaultValues(userFlagMap); if ((flagsValue & UserFlagEnum.PHONE_VERIFIED.getUserFlagValue()) == UserFlagEnum.PHONE_VERIFIED.getUserFlagValue()) { userFlagMap.put(UserFlagEnum.PHONE_VERIFIED.getUserFlagType(), true); } if ((flagsValue & UserFlagEnum.EMAIL_VERIFIED.getUserFlagValue()) == UserFlagEnum.EMAIL_VERIFIED.getUserFlagValue()) { userFlagMap.put(UserFlagEnum.EMAIL_VERIFIED.getUserFlagType(), true); } if ((flagsValue & UserFlagEnum.STATE_VALIDATED.getUserFlagValue()) == UserFlagEnum.STATE_VALIDATED.getUserFlagValue()) { userFlagMap.put(UserFlagEnum.STATE_VALIDATED.getUserFlagType(), true); } return userFlagMap; } static int getFlagValue(String userFlagType, boolean flagEnabled); static Map<String, Boolean> assignUserFlagValues(int flagsValue); } | @Test public void testAssignUserFlagValues() { Map<String, Boolean> userFlagMap = UserFlagUtil.assignUserFlagValues(1); Assert.assertEquals(true, userFlagMap.get(JsonKey.PHONE_VERIFIED)); userFlagMap = UserFlagUtil.assignUserFlagValues(2); Assert.assertEquals(true, userFlagMap.get(JsonKey.EMAIL_VERIFIED)); userFlagMap = UserFlagUtil.assignUserFlagValues(4); Assert.assertEquals(true, userFlagMap.get(JsonKey.STATE_VALIDATED)); } |
OTPUtil { private static String generateOTP() { String otpSize = ProjectUtil.getConfigValue(JsonKey.SUNBIRD_OTP_LENGTH); int codeDigits = StringUtils.isBlank(otpSize) ? MAXIMUM_OTP_LENGTH : Integer.valueOf(otpSize); GoogleAuthenticatorConfig config = new GoogleAuthenticatorConfig.GoogleAuthenticatorConfigBuilder() .setCodeDigits(codeDigits) .setKeyRepresentation(KeyRepresentation.BASE64) .build(); GoogleAuthenticator gAuth = new GoogleAuthenticator(config); GoogleAuthenticatorKey key = gAuth.createCredentials(); String secret = key.getKey(); int code = gAuth.getTotpPassword(secret); return String.valueOf(code); } private OTPUtil(); static String generateOtp(RequestContext context); static void sendOTPViaSMS(Map<String, Object> otpMap, RequestContext context); static String getEmailPhoneByUserId(String userId, String type, RequestContext context); static Request sendOTPViaEmail(
Map<String, Object> emailTemplateMap, String otpType, RequestContext context); static Request sendOTPViaEmail(
Map<String, Object> emailTemplateMap, RequestContext context); static String getOTPExpirationInMinutes(); } | @Test public void generateOtpTest() { for (int i = 0; i < 10000; i++) { String code = OTPUtil.generateOtp(null); Assert.assertTrue(code.length() >= 4); } } |
RoleDaoImpl implements RoleDao { @SuppressWarnings("unchecked") @Override public List<Role> getRoles() { Response roleResults = getCassandraOperation().getAllRecords(Util.KEY_SPACE_NAME, TABLE_NAME, null); TypeReference<List<Role>> roleMapType = new TypeReference<List<Role>>() {}; List<Map<String, Object>> roleMapList = (List<Map<String, Object>>) roleResults.get(JsonKey.RESPONSE); List<Role> roleList = mapper.convertValue(roleMapList, roleMapType); return roleList; } static RoleDao getInstance(); @SuppressWarnings("unchecked") @Override List<Role> getRoles(); CassandraOperation getCassandraOperation(); } | @Test public void testGetRoles() { try { cassandraOperation = PowerMockito.mock(CassandraOperation.class); PowerMockito.mockStatic(ServiceFactory.class); when(ServiceFactory.getInstance()).thenReturn(cassandraOperation); when(cassandraOperation.getAllRecords(Util.KEY_SPACE_NAME, TABLE_NAME, null)) .thenReturn(response); List<Role> roleList = roleDao.getRoles(); Assert.assertEquals("TEACHER", roleList.get(0).getName()); } catch (Exception e) { Assert.assertTrue(false); } } |
UserLookUp { public void checkEmailUniqueness(String email, RequestContext context) { if (StringUtils.isNotBlank(email)) { List<Map<String, Object>> userMapList = getEmailByType(email, context); if (CollectionUtils.isNotEmpty(userMapList)) { ProjectCommonException.throwClientErrorException(ResponseCode.emailAlreadyExistError, null); } } } Response insertRecords(List<Map<String, Object>> reqMap, RequestContext context); void deleteRecords(List<Map<String, String>> reqMap, RequestContext context); Response insertExternalIdIntoUserLookup(
List<Map<String, Object>> reqMap, String userId, RequestContext context); List<Map<String, Object>> getRecordByType(
String type, String value, boolean encrypt, RequestContext context); List<Map<String, Object>> getEmailByType(String email, RequestContext context); void checkEmailUniqueness(String email, RequestContext context); void checkEmailUniqueness(User user, String opType, RequestContext context); List<Map<String, Object>> getPhoneByType(String phone, RequestContext context); void checkPhoneUniqueness(String phone, RequestContext context); void checkPhoneUniqueness(User user, String opType, RequestContext context); boolean checkUsernameUniqueness(
String username, boolean isEncrypted, RequestContext context); void checkExternalIdUniqueness(User user, String operation, RequestContext context); } | @Test public void checkEmailUniqueness() throws Exception { boolean response = false; try { new UserLookUp().checkEmailUniqueness("[email protected]", null); response = true; } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); } assertFalse(response); }
@Test public void checkEmailUniquenessWithOpType() throws Exception { User user = new User(); user.setEmail("[email protected]"); boolean response = false; try { new UserLookUp().checkEmailUniqueness(user, "create", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), 400); } assertFalse(response); } |
BackGroundServiceActor extends BaseActor { private void updateUserCount(Request actorMessage) { ProjectLogger.log("In BackgroundService actor in updateUserCount method."); Util.DbInfo locDbInfo = Util.dbInfoMap.get(JsonKey.GEO_LOCATION_DB); List<Object> locationIds = (List<Object>) actorMessage.getRequest().get(JsonKey.LOCATION_IDS); String operation = (String) actorMessage.getRequest().get(JsonKey.OPERATION); ProjectLogger.log("operation for updating UserCount" + operation); Response response = cassandraOperation.getRecordsByProperty( locDbInfo.getKeySpace(), locDbInfo.getTableName(), JsonKey.ID, locationIds, null); List<Map<String, Object>> list = (List<Map<String, Object>>) response.get(JsonKey.RESPONSE); if (null != list && !list.isEmpty()) { for (Map<String, Object> map : list) { String locationId = (String) map.get(JsonKey.ID); ProjectLogger.log("Processing start for LocationId " + locationId); Long userCountTTL = 0L; int userCount = (map.get(JsonKey.USER_COUNT) == null) ? 0 : (int) (map.get(JsonKey.USER_COUNT)); ProjectLogger.log("userCount is " + userCount + "for location id " + locationId); if (userCount == 0 && !StringUtils.isBlank(operation) && operation.equalsIgnoreCase("UpdateUserCountScheduler")) { ProjectLogger.log("Processing start for LocationId for Scheduler " + locationId); int count = getUserCount(locationId); Map<String, Object> reqMap = new HashMap<>(); reqMap.put(JsonKey.ID, locationId); reqMap.put(JsonKey.USER_COUNT, count); reqMap.put(JsonKey.USER_COUNT_TTL, String.valueOf(System.currentTimeMillis())); cassandraOperation.updateRecord( locDbInfo.getKeySpace(), locDbInfo.getTableName(), reqMap, null); } else if (!StringUtils.isBlank(operation) && operation.equalsIgnoreCase("GeoLocationManagementActor")) { ProjectLogger.log( "Processing start for LocationId for GeoLocationManagementActor " + locationId); try { if (!StringUtils.isBlank((String) map.get(JsonKey.USER_COUNT_TTL))) { userCountTTL = Long.valueOf((String) map.get(JsonKey.USER_COUNT_TTL)); } } catch (Exception ex) { ProjectLogger.log( "Exception occurred while converting string to long " + (String) map.get(JsonKey.USER_COUNT_TTL)); userCountTTL = 0L; } ProjectLogger.log("userCountTTL == " + userCountTTL); Long currentTime = System.currentTimeMillis(); Long diff = currentTime - userCountTTL; int hours = (int) (diff / (1000 * 60 * 60)); if (hours >= 24) { ProjectLogger.log("Updating user count for LocnId " + locationId); int usrCount = getUserCount(locationId); Map<String, Object> reqMap = new HashMap<>(); reqMap.put(JsonKey.ID, locationId); reqMap.put(JsonKey.USER_COUNT, usrCount); reqMap.put(JsonKey.USER_COUNT_TTL, String.valueOf(System.currentTimeMillis())); cassandraOperation.updateRecord( locDbInfo.getKeySpace(), locDbInfo.getTableName(), reqMap, null); } } } ProjectLogger.log("Processing end user count update "); } } @Override void onReceive(Request request); } | @Test @Ignore public void updateUserCountTest() { Map<String, Object> locnMap = new HashMap<String, Object>(); locnMap.put(JsonKey.ID, locnId); locnMap.put(JsonKey.USER_COUNT, 0); cassandraOperation.updateRecord( geoLocationDbInfo.getKeySpace(), geoLocationDbInfo.getTableName(), locnMap, null); List<Object> locnIdList = new ArrayList<>(); locnIdList.add(locnId); TestKit probe = new TestKit(system); ActorRef subject = system.actorOf(props); Request actorMessage = new Request(); actorMessage.getRequest().put(JsonKey.LOCATION_IDS, locnIdList); actorMessage.getRequest().put(JsonKey.OPERATION, "GeoLocationManagementActor"); actorMessage.setOperation(BackgroundOperations.updateUserCountToLocationID.name()); subject.tell(actorMessage, probe.getRef()); try { Thread.sleep(20000); } catch (InterruptedException e) { ProjectLogger.log(e.getMessage(), e); } Response response = cassandraOperation.getRecordById( geoLocationDbInfo.getKeySpace(), geoLocationDbInfo.getTableName(), locnId, null); List<Map<String, Object>> reslist = (List<Map<String, Object>>) response.get(JsonKey.RESPONSE); Map<String, Object> map = reslist.get(0); int count = (int) map.get(JsonKey.USER_COUNT); boolean bool = (count >= 0) ? true : false; assertTrue(bool); } |
EmailTemplateDaoImpl implements EmailTemplateDao { @Override public String getTemplate(String templateName, RequestContext context) { List<String> idList = new ArrayList<>(); if (StringUtils.isBlank(templateName)) { idList.add(DEFAULT_EMAIL_TEMPLATE_NAME); } else { idList.add(templateName); } Response response = getCassandraOperation() .getRecordsByPrimaryKeys( JsonKey.SUNBIRD, EMAIL_TEMPLATE, idList, JsonKey.NAME, context); List<Map<String, Object>> emailTemplateList = (List<Map<String, Object>>) response.get(JsonKey.RESPONSE); Map<String, Object> map = Collections.emptyMap(); if (CollectionUtils.isNotEmpty(emailTemplateList)) { map = emailTemplateList.get(0); } return (String) map.get(TEMPLATE); } static EmailTemplateDao getInstance(); @Override String getTemplate(String templateName, RequestContext context); } | @Test public void testGetTemplateWithBlankTemplateName() { List<String> idList = new ArrayList<>(); idList.add(DEFAULT_EMAIL_TEMPLATE_NAME); Response response = new Response(); List<Map<String, Object>> orgList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); orgList.add(map); response.put(JsonKey.RESPONSE, orgList); when(cassandraOperation.getRecordsByPrimaryKeys( JsonKey.SUNBIRD, EMAIL_TEMPLATE, idList, JsonKey.NAME, null)) .thenReturn(response); String resp = emailTemplateDao.getTemplate(StringUtils.EMPTY, null); Assert.assertEquals(null, resp); }
@Test public void testGetTemplateWithTemplateName() { List<String> idList = new ArrayList<>(); idList.add("Sunbird_email_template"); Response response = new Response(); List<Map<String, Object>> orgList = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(TEMPLATE, "Course is Been completed"); orgList.add(map); response.put(JsonKey.RESPONSE, orgList); when(cassandraOperation.getRecordsByPrimaryKeys( JsonKey.SUNBIRD, EMAIL_TEMPLATE, idList, JsonKey.NAME, null)) .thenReturn(response); String resp = emailTemplateDao.getTemplate("Sunbird_email_template", null); Assert.assertEquals("Course is Been completed", resp); } |
EmailTemplateDaoImpl implements EmailTemplateDao { public static EmailTemplateDao getInstance() { if (emailTemplateDao == null) { emailTemplateDao = new EmailTemplateDaoImpl(); } return emailTemplateDao; } static EmailTemplateDao getInstance(); @Override String getTemplate(String templateName, RequestContext context); } | @Test public void testGetInstance() { Assert.assertEquals( emailTemplateDao.getClass().getSimpleName(), EmailTemplateDaoImpl.getInstance().getClass().getSimpleName()); } |
OnDemandSchedulerManager extends SchedulerManager { public void triggerScheduler(String[] jobs) { String identifier = "NetOps-PC1502295457753"; for (String job : jobs) { switch (job) { case BULK_UPLOAD: case SHADOW_USER: scheduleOnDemand(identifier, job); break; default: ProjectLogger.log( "OnDemandSchedulerManager:triggerScheduler: There is no such job", LoggerEnum.INFO.name()); } } } OnDemandSchedulerManager(); void scheduleOnDemand(String identifier, String job); static OnDemandSchedulerManager getInstance(); void triggerScheduler(String[] jobs); static Map<String, String> schedulerMap; } | @Test public void testTriggerScheduler() throws SchedulerException { PowerMockito.suppress(PowerMockito.constructor(SchedulerManager.class)); PowerMockito.suppress(PowerMockito.methodsDeclaredIn(SchedulerManager.class)); scheduler = mock(Scheduler.class); PowerMockito.mockStatic(SchedulerManager.class); String[] jobs = {"shadowuser"}; onDemandSchedulerManager = spy(OnDemandSchedulerManager.class); when(scheduler.checkExists((JobKey) Mockito.anyObject())).thenReturn(false); onDemandSchedulerManager.triggerScheduler(jobs); verify(onDemandSchedulerManager).scheduleOnDemand(Mockito.anyString(), Mockito.anyString()); } |
UserBulkMigrationRequestValidator { public void validate() { ProjectLogger.log( "UserBulkMigrationRequestValidator:validate:start validating migration users", LoggerEnum.INFO.name()); checkCsvRows(); } private UserBulkMigrationRequestValidator(ShadowUserUpload migration); static UserBulkMigrationRequestValidator getInstance(ShadowUserUpload migration); void validate(); void validateDeclaredUsers(); void checkEmailAndPhone(String email, String phone, int index); } | @Test public void testRowsCountFailureWithEmptyCSVFile() { List<MigrationUser> migrationUserList = new ArrayList<>(); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals(ResponseCode.noDataForConsumption.getErrorMessage(), e.getMessage()); } }
@Test public void testRowsCountFailureWithMoreCsvRowsSupported() { List<MigrationUser> migrationUserList = new ArrayList<>(); for (int i = 0; i < MAX_ROW_SUPPORTED + 1; i++) { MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUserList.add(migrationUser); } try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("2024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals( ResponseCode.csvRowsExceeds.getErrorMessage().concat("supported:" + MAX_ROW_SUPPORTED), e.getMessage()); } }
@Test public void testShadowUserMigrationWithBlankName() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setPhone("9876543210"); migrationUser.setInputStatus(JsonKey.ACTIVE); migrationUser.setOrgExternalId("org ext id"); migrationUser.setUserExternalId("user ext id"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column name:is missing ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithBlankEmail() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus(JsonKey.ACTIVE); migrationUser.setOrgExternalId("org ext id"); migrationUser.setName("Shadow User Name"); migrationUser.setUserExternalId("user ext id"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column email:is missing ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithInvalidEmail() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus(JsonKey.ACTIVE); migrationUser.setOrgExternalId("org ext id"); migrationUser.setEmail("wrongemail"); migrationUser.setName("Shadow User Name"); migrationUser.setUserExternalId("user ext id"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { System.out.println(e.getMessage()); Assert.assertEquals("[ In Row 1:the Column email:is invalid ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithInvalidPhone() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus(JsonKey.ACTIVE); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("987897"); migrationUser.setName("Shadow User Name"); migrationUser.setUserExternalId("user ext id"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column phone:is invalid ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithBlankUserExtId() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus(JsonKey.ACTIVE); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("9876543210"); migrationUser.setName("Shadow User Name"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column userExternalId:is missing ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithBlankInputStatus() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("9876543210"); migrationUser.setUserExternalId("any user ext id"); migrationUser.setName("Shadow User Name"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column input status:is missing ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithInvalidInputStatus() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus("wrong input status"); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("9876543210"); migrationUser.setUserExternalId("any user ext id"); migrationUser.setName("Shadow User Name"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column input status:is invalid ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithDuplicateUserExtId() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus("Active"); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("9876543210"); migrationUser.setUserExternalId("any user ext id"); migrationUser.setName("Shadow User Name"); migrationUserList.add(migrationUser); MigrationUser anotherMigrationUser = new MigrationUser(); anotherMigrationUser.setChannel("TN"); anotherMigrationUser.setInputStatus("Active"); anotherMigrationUser.setOrgExternalId("org ext id"); anotherMigrationUser.setPhone("9876543210"); anotherMigrationUser.setUserExternalId("any user ext id"); anotherMigrationUser.setName("Shadow User Name"); migrationUserList.add(anotherMigrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { Assert.assertEquals("[ In Row 2:the Column userExternalId:is duplicate ]", e.getMessage()); } }
@Test public void testShadowUserMigrationWithInvalidName() { List<MigrationUser> migrationUserList = new ArrayList<>(); MigrationUser migrationUser = new MigrationUser(); migrationUser.setChannel("TN"); migrationUser.setInputStatus("Active"); migrationUser.setOrgExternalId("org ext id"); migrationUser.setPhone("9876543210"); migrationUser.setUserExternalId("any user ext id"); migrationUser.setName("###Shadow User Name"); migrationUserList.add(migrationUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(migrationUserList) .validate(); } catch (Exception e) { System.out.println(e.getMessage()); Assert.assertEquals("[ In Row 1:the Column name:is invalid ]", e.getMessage()); } } |
UserBulkMigrationRequestValidator { public void validateDeclaredUsers() { ProjectLogger.log( "UserBulkMigrationRequestValidator:validate:start validating migration users", LoggerEnum.INFO.name()); checkDeclaredCsvRows(); } private UserBulkMigrationRequestValidator(ShadowUserUpload migration); static UserBulkMigrationRequestValidator getInstance(ShadowUserUpload migration); void validate(); void validateDeclaredUsers(); void checkEmailAndPhone(String email, String phone, int index); } | @Test public void testRowsCountFailureWithEmptyCSVFileForDeclaredUsers() { List<MigrationUser> declaredUserList = new ArrayList<>(); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setValues(declaredUserList) .validateDeclaredUsers(); } catch (Exception e) { Assert.assertEquals(ResponseCode.noDataForConsumption.getErrorMessage(), e.getMessage()); } }
@Test public void testRowsCountFailureWithMoreCsvRowsSupportedForDeclaredUsers() { List<SelfDeclaredUser> declaredUserList = new ArrayList<>(); for (int i = 0; i < MAX_ROW_SUPPORTED + 1; i++) { SelfDeclaredUser declaredUser = new SelfDeclaredUser(); declaredUser.setChannel("TN"); declaredUserList.add(declaredUser); } try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("2024") .setUserValues(declaredUserList) .validateDeclaredUsers(); } catch (Exception e) { Assert.assertEquals( ResponseCode.csvRowsExceeds.getErrorMessage().concat("supported:" + MAX_ROW_SUPPORTED), e.getMessage()); } }
@Test public void testMigrationWithBlankStatusDikshaUUIDForDeclaredUsers() { List<SelfDeclaredUser> declaredUserList = new ArrayList<>(); SelfDeclaredUser declaredUser = new SelfDeclaredUser(); declaredUser.setChannel("TN"); declaredUser.setPhone("9876543210"); declaredUser.setInputStatus(JsonKey.ACTIVE); declaredUser.setOrgExternalId("org ext id"); declaredUser.setUserExternalId("user ext id"); declaredUserList.add(declaredUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setUserValues(declaredUserList) .validateDeclaredUsers(); } catch (Exception e) { Assert.assertEquals( "[ In Row 1:the Column status:is invalid, In Row 1:the Column Diksha UUID:is missing, In Row 1:the Column persona:is missing ]", e.getMessage()); } }
@Test public void testMigrationWithInValidStatusDikshaUUIDForDeclaredUsers() { List<SelfDeclaredUser> declaredUserList = new ArrayList<>(); SelfDeclaredUser declaredUser = new SelfDeclaredUser(); declaredUser.setChannel("TN"); declaredUser.setPhone("9876543210"); declaredUser.setInputStatus(JsonKey.ACTIVE); declaredUser.setOrgExternalId("org ext id"); declaredUser.setUserExternalId("user ext id"); declaredUser.setInputStatus("INVALIDATED"); declaredUser.setUserId("user ext id"); declaredUser.setPersona("teacher"); declaredUserList.add(declaredUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setUserValues(declaredUserList) .validateDeclaredUsers(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column status:is invalid ]", e.getMessage()); } }
@Test public void testMigrationWithInValidErrorTypeForDeclaredUsers() { List<SelfDeclaredUser> declaredUserList = new ArrayList<>(); SelfDeclaredUser declaredUser = new SelfDeclaredUser(); declaredUser.setChannel("TN"); declaredUser.setPhone("9876543210"); declaredUser.setInputStatus(JsonKey.SELF_DECLARED_ERROR); declaredUser.setOrgExternalId("org ext id"); declaredUser.setUserId("user ext id"); declaredUser.setErrorType("INVALIDATED"); declaredUser.setUserExternalId("user ext id"); declaredUser.setPersona("teacher"); declaredUserList.add(declaredUser); try { new ShadowUserUpload.ShadowUserUploadBuilder() .setProcessId(ProjectUtil.generateUniqueId()) .setFileSize("1024") .setUserValues(declaredUserList) .validateDeclaredUsers(); } catch (Exception e) { Assert.assertEquals("[ In Row 1:the Column Error Type:is invalid ]", e.getMessage()); } } |
UserLookUp { public void checkExternalIdUniqueness(User user, String operation, RequestContext context) { if (CollectionUtils.isNotEmpty(user.getExternalIds())) { for (Map<String, String> externalId : user.getExternalIds()) { if (StringUtils.isNotBlank(externalId.get(JsonKey.ID)) && StringUtils.isNotBlank(externalId.get(JsonKey.PROVIDER)) && StringUtils.isNotBlank(externalId.get(JsonKey.ID_TYPE))) { String externalIdWithOrg = externalId.get(JsonKey.ID) + "@" + externalId.get(JsonKey.PROVIDER); List<Map<String, Object>> externalIdsRecord = getRecordByType( JsonKey.USER_LOOKUP_FILED_EXTERNAL_ID, externalIdWithOrg, false, context); if (CollectionUtils.isNotEmpty(externalIdsRecord)) { if (JsonKey.CREATE.equalsIgnoreCase(operation)) { throwUserAlreadyExistsException( externalId.get(JsonKey.ID), externalId.get(JsonKey.ID_TYPE), externalId.get(JsonKey.PROVIDER)); } else if (JsonKey.UPDATE.equalsIgnoreCase(operation)) { String userId = (String) externalIdsRecord.get(0).get(JsonKey.USER_ID); if (!(user.getUserId().equalsIgnoreCase(userId))) { if (JsonKey.ADD.equalsIgnoreCase(externalId.get(JsonKey.OPERATION)) || StringUtils.isBlank(externalId.get(JsonKey.OPERATION))) { throw new ProjectCommonException( ResponseCode.externalIdAssignedToOtherUser.getErrorCode(), ProjectUtil.formatMessage( ResponseCode.externalIdAssignedToOtherUser.getErrorMessage(), externalId.get(JsonKey.ID), externalId.get(JsonKey.ID_TYPE), externalId.get(JsonKey.PROVIDER)), ResponseCode.CLIENT_ERROR.getResponseCode()); } else { throwExternalIDNotFoundException( externalId.get(JsonKey.ID), externalId.get(JsonKey.ID_TYPE), externalId.get(JsonKey.PROVIDER)); } } } } else { if (JsonKey.UPDATE.equalsIgnoreCase(operation) && JsonKey.REMOVE.equalsIgnoreCase(externalId.get(JsonKey.OPERATION))) { throwExternalIDNotFoundException( externalId.get(JsonKey.ID), externalId.get(JsonKey.ID_TYPE), externalId.get(JsonKey.PROVIDER)); } } } } } } Response insertRecords(List<Map<String, Object>> reqMap, RequestContext context); void deleteRecords(List<Map<String, String>> reqMap, RequestContext context); Response insertExternalIdIntoUserLookup(
List<Map<String, Object>> reqMap, String userId, RequestContext context); List<Map<String, Object>> getRecordByType(
String type, String value, boolean encrypt, RequestContext context); List<Map<String, Object>> getEmailByType(String email, RequestContext context); void checkEmailUniqueness(String email, RequestContext context); void checkEmailUniqueness(User user, String opType, RequestContext context); List<Map<String, Object>> getPhoneByType(String phone, RequestContext context); void checkPhoneUniqueness(String phone, RequestContext context); void checkPhoneUniqueness(User user, String opType, RequestContext context); boolean checkUsernameUniqueness(
String username, boolean isEncrypted, RequestContext context); void checkExternalIdUniqueness(User user, String operation, RequestContext context); } | @Test public void testCheckExternalIdUniquenessSuccessForCreate() { try { new UserLookUp().checkExternalIdUniqueness(user, JsonKey.CREATE, null); } catch (ProjectCommonException e) { assertEquals(ResponseCode.userAlreadyExists.getErrorCode(), e.getCode()); } }
@Test public void testCheckExternalIdUniquenessSuccessWithUpdateOperation() { try { user.setUserId("someUserId2"); user.getExternalIds().get(0).put(JsonKey.OPERATION, JsonKey.UPDATE); new UserLookUp().checkExternalIdUniqueness(user, JsonKey.UPDATE, null); } catch (ProjectCommonException e) { assertEquals(ResponseCode.externalIdNotFound.getErrorCode(), e.getCode()); } }
@Test public void testCheckExternalIdUniquenessSuccessForUpdate() { try { user.setUserId("someUserId2"); user.getExternalIds().get(0).remove(JsonKey.OPERATION); new UserLookUp().checkExternalIdUniqueness(user, JsonKey.UPDATE, null); } catch (ProjectCommonException e) { assertEquals(ResponseCode.externalIdAssignedToOtherUser.getErrorCode(), e.getCode()); } }
@Test public void testCheckExternalIdUniquenessSuccessWithRemoveOperation() { try { user.setUserId("someUserId2"); user.getExternalIds().get(0).put(JsonKey.OPERATION, JsonKey.REMOVE); new UserLookUp().checkExternalIdUniqueness(user, JsonKey.UPDATE, null); } catch (ProjectCommonException e) { assertEquals(ResponseCode.externalIdNotFound.getErrorCode(), e.getCode()); } } |
UserBulkUploadRequestValidator { public static void validateUserBulkUploadRequest(Map<String, Object> userMap) { validateUserType(userMap); validateOrganisationId(userMap); } private UserBulkUploadRequestValidator(); static void validateUserBulkUploadRequest(Map<String, Object> userMap); static void validateUserType(Map<String, Object> userMap); static void validateOrganisationId(Map<String, Object> userMap); } | @Test public void testValidateOrganisationIdWithMandatoryParamMissing() { Map<String, Object> userMap = new HashMap<>(); userMap.put(JsonKey.USER_TYPE, UserType.TEACHER.getTypeName()); try { UserBulkUploadRequestValidator.validateUserBulkUploadRequest(userMap); } catch (Exception e) { Assert.assertEquals("Mandatory parameter orgId or orgExternalId is missing.", e.getMessage()); } }
@Test public void testValidateUserTypeWithMissingUserTypeParam() { Map<String, Object> userMap = new HashMap<>(); try { userMap.put(JsonKey.USER_TYPE, "invalid"); UserBulkUploadRequestValidator.validateUserBulkUploadRequest(userMap); } catch (Exception e) { Assert.assertEquals( "Invalid userType: invalid. Valid values are: [TEACHER, OTHER].", e.getMessage()); } }
@Test public void testUserBulkRequestValidatorSuccess() { Map<String, Object> userMap = new HashMap<>(); try { userMap.put(JsonKey.USER_TYPE, UserType.TEACHER.getTypeName()); userMap.put(JsonKey.ORG_ID, "anyOrgId"); UserBulkUploadRequestValidator.validateUserBulkUploadRequest(userMap); } catch (Exception e) { System.out.println(e.getMessage()); Assert.assertTrue(false); } } |
FeedUtil { public static Response saveFeed( ShadowUser shadowUser, List<String> userIds, RequestContext context) { return saveFeed(shadowUser, userIds.get(0), context); } static Response saveFeed(
ShadowUser shadowUser, List<String> userIds, RequestContext context); static Response saveFeed(ShadowUser shadowUser, String userId, RequestContext context); } | @Test public void saveFeedInsertTest() { List<String> userIds = new ArrayList<>(); userIds.add("123-456-7890"); Response response = FeedUtil.saveFeed(getShadowUser(), userIds, null); Assert.assertNotNull(response); } |
FeedServiceImpl implements IFeedService { @Override public Response insert(Feed feed, RequestContext context) { logger.info(context, "FeedServiceImpl:insert method called : "); Map<String, Object> feedData = feed.getData(); Map<String, Object> dbMap = mapper.convertValue(feed, Map.class); String feedId = ProjectUtil.generateUniqueId(); dbMap.put(JsonKey.ID, feedId); dbMap.put(JsonKey.CREATED_ON, new Timestamp(Calendar.getInstance().getTimeInMillis())); try { if (MapUtils.isNotEmpty(feed.getData())) { dbMap.put(JsonKey.FEED_DATA, mapper.writeValueAsString(feed.getData())); } } catch (Exception ex) { logger.error(context, "FeedServiceImpl:insert Exception occurred while mapping.", ex); } Response response = saveFeed(dbMap, context); dbMap.put(JsonKey.FEED_DATA, feedData); dbMap.put(JsonKey.CREATED_ON, Calendar.getInstance().getTimeInMillis()); getESInstance().save(ProjectUtil.EsType.userfeed.getTypeName(), feedId, dbMap, context); return response; } static CassandraOperation getCassandraInstance(); static ElasticSearchService getESInstance(); @Override Response insert(Feed feed, RequestContext context); @Override Response update(Feed feed, RequestContext context); @Override List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context); @Override Response search(SearchDTO searchDTO, RequestContext context); @Override void delete(String id, String userId, String category, RequestContext context); } | @Test public void testInsert() { Response res = feedService.insert(getFeed(false), null); Assert.assertTrue( ((String) res.getResult().get(JsonKey.RESPONSE)).equalsIgnoreCase(JsonKey.SUCCESS)); } |
FeedServiceImpl implements IFeedService { @Override public Response update(Feed feed, RequestContext context) { logger.info(context, "FeedServiceImpl:update method called : "); Map<String, Object> feedData = feed.getData(); Map<String, Object> dbMap = mapper.convertValue(feed, Map.class); try { if (MapUtils.isNotEmpty(feed.getData())) { dbMap.put(JsonKey.FEED_DATA, mapper.writeValueAsString(feed.getData())); } } catch (Exception ex) { logger.error(context, "FeedServiceImpl:update Exception occurred while mapping.", ex); } dbMap.remove(JsonKey.CREATED_ON); dbMap.put(JsonKey.UPDATED_ON, new Timestamp(Calendar.getInstance().getTimeInMillis())); Response response = saveFeed(dbMap, context); dbMap.put(JsonKey.FEED_DATA, feedData); dbMap.put(JsonKey.UPDATED_ON, Calendar.getInstance().getTimeInMillis()); getESInstance().update(ProjectUtil.EsType.userfeed.getTypeName(), feed.getId(), dbMap, context); return response; } static CassandraOperation getCassandraInstance(); static ElasticSearchService getESInstance(); @Override Response insert(Feed feed, RequestContext context); @Override Response update(Feed feed, RequestContext context); @Override List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context); @Override Response search(SearchDTO searchDTO, RequestContext context); @Override void delete(String id, String userId, String category, RequestContext context); } | @Test public void testUpdate() { Response res = feedService.update(getFeed(true), null); Assert.assertTrue( ((String) res.getResult().get(JsonKey.RESPONSE)).equalsIgnoreCase(JsonKey.SUCCESS)); } |
FeedServiceImpl implements IFeedService { @Override public void delete(String id, String userId, String category, RequestContext context) { logger.info(context, "FeedServiceImpl:delete method called for feedId : " + id); Map<String, String> compositeKey = new HashMap(); compositeKey.put("userid", userId); compositeKey.put("id", id); compositeKey.put("category", category); getCassandraInstance() .deleteRecord( usrFeedDbInfo.getKeySpace(), usrFeedDbInfo.getTableName(), compositeKey, context); getESInstance().delete(ProjectUtil.EsType.userfeed.getTypeName(), id, context); } static CassandraOperation getCassandraInstance(); static ElasticSearchService getESInstance(); @Override Response insert(Feed feed, RequestContext context); @Override Response update(Feed feed, RequestContext context); @Override List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context); @Override Response search(SearchDTO searchDTO, RequestContext context); @Override void delete(String id, String userId, String category, RequestContext context); } | @Test public void testDelete() { boolean response = false; try { feedService.delete("123-456-789", null, null, null); response = true; } catch (Exception ex) { Assert.assertTrue(response); } Assert.assertTrue(response); } |
FeedServiceImpl implements IFeedService { @Override public List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context) { logger.info(context, "FeedServiceImpl:getRecordsByUserId method called : "); Response dbResponse = getCassandraInstance() .getRecordById( usrFeedDbInfo.getKeySpace(), usrFeedDbInfo.getTableName(), properties, context); List<Map<String, Object>> responseList = null; List<Feed> feedList = new ArrayList<>(); if (null != dbResponse && null != dbResponse.getResult()) { responseList = (List<Map<String, Object>>) dbResponse.getResult().get(JsonKey.RESPONSE); if (CollectionUtils.isNotEmpty(responseList)) { responseList.forEach( s -> { try { String data = (String) s.get(JsonKey.FEED_DATA); if (StringUtils.isNotBlank(data)) { s.put( JsonKey.FEED_DATA, mapper.readValue(data, new TypeReference<Map<String, Object>>() {})); } else { s.put(JsonKey.FEED_DATA, Collections.emptyMap()); } feedList.add(mapper.convertValue(s, Feed.class)); } catch (Exception ex) { logger.error( context, "FeedServiceImpl:getRecordsByUserId :Exception occurred while mapping feed data.", ex); } }); } } return feedList; } static CassandraOperation getCassandraInstance(); static ElasticSearchService getESInstance(); @Override Response insert(Feed feed, RequestContext context); @Override Response update(Feed feed, RequestContext context); @Override List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context); @Override Response search(SearchDTO searchDTO, RequestContext context); @Override void delete(String id, String userId, String category, RequestContext context); } | @Test public void testGetRecordsByProperties() { Map<String, Object> props = new HashMap<>(); props.put(JsonKey.USER_ID, "123-456-789"); List<Feed> res = feedService.getRecordsByUserId(props, null); Assert.assertTrue(res != null); } |
FeedServiceImpl implements IFeedService { @Override public Response search(SearchDTO searchDTO, RequestContext context) { logger.info(context, "FeedServiceImpl:search method called : "); Future<Map<String, Object>> resultF = getESInstance().search(searchDTO, ProjectUtil.EsType.userfeed.getTypeName(), context); Map<String, Object> result = (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(resultF); Response response = new Response(); response.put(JsonKey.RESPONSE, result); return response; } static CassandraOperation getCassandraInstance(); static ElasticSearchService getESInstance(); @Override Response insert(Feed feed, RequestContext context); @Override Response update(Feed feed, RequestContext context); @Override List<Feed> getRecordsByUserId(Map<String, Object> properties, RequestContext context); @Override Response search(SearchDTO searchDTO, RequestContext context); @Override void delete(String id, String userId, String category, RequestContext context); } | @Test public void testSearch() { Response response = feedService.search(search, null); when(ElasticSearchHelper.getResponseFromFuture(Mockito.any())).thenReturn(esResponse); PowerMockito.when(esUtil.search(search, ProjectUtil.EsType.userfeed.getTypeName(), null)) .thenReturn(promise.future()); Assert.assertTrue(esResponse != null); } |
KeyManager { public static PublicKey loadPublicKey(String key) throws Exception { String publicKey = new String(key.getBytes(), StandardCharsets.UTF_8); publicKey = publicKey.replaceAll("(-+BEGIN PUBLIC KEY-+)", ""); publicKey = publicKey.replaceAll("(-+END PUBLIC KEY-+)", ""); publicKey = publicKey.replaceAll("[\\r\\n]+", ""); byte[] keyBytes = Base64Util.decode(publicKey.getBytes("UTF-8"), Base64Util.DEFAULT); X509EncodedKeySpec X509publicKey = new X509EncodedKeySpec(keyBytes); KeyFactory kf = KeyFactory.getInstance("RSA"); return kf.generatePublic(X509publicKey); } static void init(); static KeyData getPublicKey(String keyId); static PublicKey loadPublicKey(String key); } | @Test public void testLoadPublicKey() throws Exception { PublicKey key = KeyManager.loadPublicKey( "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAysH/wWtg0IjBL1JZZDYvUJC42JCxVobalckr2/3d3eEiWkk7Zh/4DAPYOs4UPjAevTs5VMUjq9EZu/u4H5hNzoVmYNvhtxbhWNY3n4mxpA4Lgt4sNGiGYNNGrN34ML+7+TR3Z1dlrhA271PiuanHI11YymskQRPhBfuwK923Kl/lgI4rS9OQ4GnkvwkUPvMUIRfNt8wL9uTbWm3V9p8VTcmQbW+pPw9QhO9v95NOgXQrLnT8xwnzQE6UCTY2al3B0fc3ULmcxvK+7P1R3/0w1qJLEKSiHl0xnv4WNEfS+2UmN+8jfdSCfoyVIglQl5/tb05j89nfZZp8k24AWLxIJQIDAQAB"); assertNotNull(key); } |
KeyManager { public static KeyData getPublicKey(String keyId) { return keyMap.get(keyId); } static void init(); static KeyData getPublicKey(String keyId); static PublicKey loadPublicKey(String key); } | @Test public void testGetPublicKey() { KeyData key = KeyManager.getPublicKey("keyId"); assertNull(key); } |
AccessTokenValidator { public static String verifyUserToken(String token) { String userId = JsonKey.UNAUTHORIZED; try { Map<String, Object> payload = validateToken(token); if (MapUtils.isNotEmpty(payload) && checkIss((String) payload.get("iss"))) { userId = (String) payload.get(JsonKey.SUB); if (StringUtils.isNotBlank(userId)) { int pos = userId.lastIndexOf(":"); userId = userId.substring(pos + 1); } } } catch (Exception ex) { logger.error("Exception in verifyUserAccessToken: verify ", ex); } return userId; } static String verifyManagedUserToken(
String managedEncToken, String requestedByUserId, String requestedForUserId); static String verifyUserToken(String token); } | @Test public void verifyUserAccessToken() throws JsonProcessingException { PowerMockito.mockStatic(CryptoUtil.class); PowerMockito.mockStatic(Base64Util.class); PowerMockito.mockStatic(KeyManager.class); KeyData keyData = PowerMockito.mock(KeyData.class); Mockito.when(KeyManager.getPublicKey(Mockito.anyString())).thenReturn(keyData); PublicKey publicKey = PowerMockito.mock(PublicKey.class); Mockito.when(keyData.getPublicKey()).thenReturn(publicKey); Map<String, Object> payload = new HashMap<>(); int expTime = Time.currentTime() + 3600000; payload.put("exp", expTime); payload.put("iss", "nullrealms/null"); payload.put("kid", "kid"); payload.put("sub", "f:ca00376d-395f-aee687d7c8ad:10cca27c-2a13-443c-9e2b-c7d9589c1f5f"); ObjectMapper mapper = new ObjectMapper(); Mockito.when(Base64Util.decode(Mockito.any(String.class), Mockito.anyInt())) .thenReturn(mapper.writeValueAsString(payload).getBytes()); Mockito.when( CryptoUtil.verifyRSASign( Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(true); String userId = AccessTokenValidator.verifyUserToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA"); assertNotNull(userId); }
@Test public void verifyUserAccessTokenInvalidToken() throws JsonProcessingException { PowerMockito.mockStatic(CryptoUtil.class); PowerMockito.mockStatic(Base64Util.class); PowerMockito.mockStatic(KeyManager.class); KeyData keyData = PowerMockito.mock(KeyData.class); Mockito.when(KeyManager.getPublicKey(Mockito.anyString())).thenReturn(keyData); PublicKey publicKey = PowerMockito.mock(PublicKey.class); Mockito.when(keyData.getPublicKey()).thenReturn(publicKey); Map<String, Object> payload = new HashMap<>(); int expTime = Time.currentTime() + 3600000; payload.put("exp", expTime); payload.put("kid", "kid"); ObjectMapper mapper = new ObjectMapper(); Mockito.when(Base64Util.decode(Mockito.any(String.class), Mockito.anyInt())) .thenReturn(mapper.writeValueAsString(payload).getBytes()); Mockito.when( CryptoUtil.verifyRSASign( Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(false); String userId = AccessTokenValidator.verifyUserToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA"); assertEquals("Unauthorized", userId); }
@Test public void verifyUserAccessTokenExpiredToken() throws JsonProcessingException { PowerMockito.mockStatic(CryptoUtil.class); PowerMockito.mockStatic(Base64Util.class); PowerMockito.mockStatic(KeyManager.class); KeyData keyData = PowerMockito.mock(KeyData.class); Mockito.when(KeyManager.getPublicKey(Mockito.anyString())).thenReturn(keyData); PublicKey publicKey = PowerMockito.mock(PublicKey.class); Mockito.when(keyData.getPublicKey()).thenReturn(publicKey); Map<String, Object> payload = new HashMap<>(); int expTime = Time.currentTime() - 3600000; payload.put("exp", expTime); payload.put("kid", "kid"); ObjectMapper mapper = new ObjectMapper(); Mockito.when(Base64Util.decode(Mockito.any(String.class), Mockito.anyInt())) .thenReturn(mapper.writeValueAsString(payload).getBytes()); Mockito.when( CryptoUtil.verifyRSASign( Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(true); String userId = AccessTokenValidator.verifyUserToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA"); assertEquals("Unauthorized", userId); } |
AccessTokenValidator { public static String verifyManagedUserToken( String managedEncToken, String requestedByUserId, String requestedForUserId) { String managedFor = JsonKey.UNAUTHORIZED; try { Map<String, Object> payload = validateToken(managedEncToken); if (MapUtils.isNotEmpty(payload)) { String parentId = (String) payload.get(JsonKey.PARENT_ID); String muaId = (String) payload.get(JsonKey.SUB); logger.info( "AccessTokenValidator: parent uuid: " + parentId + " managedBy uuid: " + muaId + " requestedByUserID: " + requestedByUserId + " requestedForUserId: " + requestedForUserId); boolean isValid = parentId.equalsIgnoreCase(requestedByUserId) && muaId.equalsIgnoreCase(requestedForUserId); if (isValid) { managedFor = muaId; } } } catch (Exception ex) { logger.error("Exception in AccessTokenValidator: verify ", ex); } return managedFor; } static String verifyManagedUserToken(
String managedEncToken, String requestedByUserId, String requestedForUserId); static String verifyUserToken(String token); } | @Test public void verifyToken() throws JsonProcessingException { PowerMockito.mockStatic(CryptoUtil.class); PowerMockito.mockStatic(Base64Util.class); PowerMockito.mockStatic(KeyManager.class); KeyData keyData = PowerMockito.mock(KeyData.class); Mockito.when(KeyManager.getPublicKey(Mockito.anyString())).thenReturn(keyData); PublicKey publicKey = PowerMockito.mock(PublicKey.class); Mockito.when(keyData.getPublicKey()).thenReturn(publicKey); Map<String, Object> payload = new HashMap<>(); int expTime = Time.currentTime() + 3600000; payload.put("exp", expTime); payload.put("requestedByUserId", "386c7960-7f85-4a24-8131-a8aba519ce7d"); payload.put("requestedForUserId", "386c7960-7f85-4a24-8131-a8aba519ce7e"); payload.put("kid", "kid"); payload.put("parentId", "386c7960-7f85-4a24-8131-a8aba519ce7d"); payload.put("sub", "386c7960-7f85-4a24-8131-a8aba519ce7e"); ObjectMapper mapper = new ObjectMapper(); Mockito.when(Base64Util.decode(Mockito.any(String.class), Mockito.anyInt())) .thenReturn(mapper.writeValueAsString(payload).getBytes()); Mockito.when( CryptoUtil.verifyRSASign( Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(true); String userId = AccessTokenValidator.verifyManagedUserToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA", "386c7960-7f85-4a24-8131-a8aba519ce7d", "386c7960-7f85-4a24-8131-a8aba519ce7e"); assertNotNull(userId); }
@Test public void verifyTokenWithNullParentId() throws JsonProcessingException { PowerMockito.mockStatic(CryptoUtil.class); PowerMockito.mockStatic(Base64Util.class); PowerMockito.mockStatic(KeyManager.class); KeyData keyData = PowerMockito.mock(KeyData.class); Mockito.when(KeyManager.getPublicKey(Mockito.anyString())).thenReturn(keyData); PublicKey publicKey = PowerMockito.mock(PublicKey.class); Mockito.when(keyData.getPublicKey()).thenReturn(publicKey); Map<String, Object> payload = new HashMap<>(); int expTime = Time.currentTime() + 3600000; payload.put("exp", expTime); payload.put("requestedByUserId", "386c7960-7f85-4a24-8131-a8aba519ce7d"); payload.put("requestedForUserId", "386c7960-7f85-4a24-8131-a8aba519ce7e"); payload.put("kid", "kid"); payload.put("sub", "386c7960-7f85-4a24-8131-a8aba519ce7e"); ObjectMapper mapper = new ObjectMapper(); Mockito.when(Base64Util.decode(Mockito.any(String.class), Mockito.anyInt())) .thenReturn(mapper.writeValueAsString(payload).getBytes()); Mockito.when( CryptoUtil.verifyRSASign( Mockito.anyString(), Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(true); try { AccessTokenValidator.verifyManagedUserToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA", "386c7960-7f85-4a24-8131-a8aba519ce7d", "386c7960-7f85-4a24-8131-a8aba519ce7e"); } catch (Exception e) { assertNotNull(e); } } |
EsClientFactory { private static ElasticSearchService getRestClient() { if (restClient == null) { synchronized (EsClientFactory.class) { if (restClient == null) { restClient = new ElasticSearchRestHighImpl(); } } } return restClient; } static ElasticSearchService getInstance(String type); } | @Test public void testGetRestClient() { ElasticSearchService service = EsClientFactory.getInstance("rest"); Assert.assertTrue(service instanceof ElasticSearchRestHighImpl); } |
EsClientFactory { public static ElasticSearchService getInstance(String type) { if (JsonKey.REST.equals(type)) { return getRestClient(); } else { ProjectLogger.log( "EsClientFactory:getInstance: value for client type provided null ", LoggerEnum.ERROR); } return null; } static ElasticSearchService getInstance(String type); } | @Test public void testInstanceNull() { ElasticSearchService service = EsClientFactory.getInstance("test"); Assert.assertNull(service); } |
ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<String> save( String index, String identifier, Map<String, Object> data, RequestContext context) { long startTime = System.currentTimeMillis(); Promise<String> promise = Futures.promise(); logger.info( context, "ElasticSearchUtilRest:save: method started at ==" + startTime + " for Index " + index); if (StringUtils.isBlank(identifier) || StringUtils.isBlank(index)) { logger.info( context, "ElasticSearchRestHighImpl:save: " + "Identifier or Index value is null or empty, identifier : " + "" + identifier + ",index: " + index + ",not able to save data."); promise.success(ERROR); return promise.future(); } data.put("identifier", identifier); IndexRequest indexRequest = new IndexRequest(index, _DOC, identifier).source(data); ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() { @Override public void onResponse(IndexResponse indexResponse) { logger.info( context, "ElasticSearchRestHighImpl:save: Success for index : " + index + ", identifier :" + identifier); promise.success(indexResponse.getId()); logger.info( context, "ElasticSearchRestHighImpl:save: method end at ==" + System.currentTimeMillis() + " for Index " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); } @Override public void onFailure(Exception e) { promise.failure(e); logger.error( context, "ElasticSearchRestHighImpl:save: " + "Error while saving " + index + " id : " + identifier, e); logger.info( context, "ElasticSearchRestHighImpl:save: method end at ==" + System.currentTimeMillis() + " for INdex " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); } }; ConnectionManager.getRestClient().indexAsync(indexRequest, listener); return promise.future(); } @Override Future<String> save(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier(
String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search(
SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert(
String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index, RequestContext context); } | @Test public void testSaveSuccess() { mockRulesForSave(false); Future<String> result = esService.save("test", "001", new HashMap<>(), null); String res = (String) ElasticSearchHelper.getResponseFromFuture(result); assertEquals("001", res); }
@Test public void testSaveFailureWithEmptyIndex() { Future<String> result = esService.save("", "001", new HashMap<>(), null); String res = (String) ElasticSearchHelper.getResponseFromFuture(result); assertEquals("ERROR", res); }
@Test public void testSaveFailureWithEmptyIdentifier() { Future<String> result = esService.save("test", "", new HashMap<>(), null); String res = (String) ElasticSearchHelper.getResponseFromFuture(result); assertEquals("ERROR", res); }
@Test public void testSaveFailure() { mockRulesForSave(true); Future<String> result = esService.save("test", "001", new HashMap<>(), null); String res = (String) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); } |
ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Map<String, Object>> getDataByIdentifier( String index, String identifier, RequestContext context) { long startTime = System.currentTimeMillis(); Promise<Map<String, Object>> promise = Futures.promise(); if (StringUtils.isNotEmpty(identifier) && StringUtils.isNotEmpty(index)) { logger.info( context, "ElasticSearchRestHighImpl:getDataByIdentifier: method started at ==" + startTime + " for Index " + index); GetRequest getRequest = new GetRequest(index, _DOC, identifier); ActionListener<GetResponse> listener = new ActionListener<GetResponse>() { @Override public void onResponse(GetResponse getResponse) { if (getResponse.isExists()) { Map<String, Object> sourceAsMap = getResponse.getSourceAsMap(); if (MapUtils.isNotEmpty(sourceAsMap)) { promise.success(sourceAsMap); logger.info( context, "ElasticSearchRestHighImpl:getDataByIdentifier: method end ==" + " for Index " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); } else { promise.success(new HashMap<>()); } } else { promise.success(new HashMap<>()); } } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:getDataByIdentifier: method Failed with error == ", e); promise.failure(e); } }; ConnectionManager.getRestClient().getAsync(getRequest, listener); } else { logger.info( context, "ElasticSearchRestHighImpl:getDataByIdentifier: " + "provided index or identifier is null, index = " + index + "," + " identifier = " + identifier); promise.failure(ProjectUtil.createClientException(ResponseCode.invalidData)); } return promise.future(); } @Override Future<String> save(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier(
String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search(
SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert(
String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert(
String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index, RequestContext context); } | @Test public void testGetDataByIdentifierFailureWithEmptyIndex() { try { esService.getDataByIdentifier("", "001", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testGetDataByIdentifierFailureWithEmptyIdentifier() { try { esService.getDataByIdentifier("test", "", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
@Test public void testGetDataByIdentifierFailure() { mockRulesForGet(true); Future<Map<String, Object>> result = esService.getDataByIdentifier("test", "001", null); Object res = ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); } |
Email { public String getPassword() { return password; } Email(); Email(EmailConfig config); boolean sendMail(List<String> emailList, String subject, String body); boolean sendMail(
List<String> emailList, String subject, String body, List<String> ccEmailList); void sendAttachment(
List<String> emailList, String emailBody, String subject, String filePath); boolean sendEmail(String fromEmail, String subject, String body, List<String> bccList); String getHost(); String getPort(); String getUserName(); String getPassword(); String getFromEmail(); } | @Test public void passwordAuthTest() { PasswordAuthentication authentication = authenticator.getPasswordAuthentication(); Assert.assertEquals("test", authentication.getPassword()); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Boolean> update(String index, String identifier, Map<String, Object> data) { long startTime = System.currentTimeMillis(); Promise<Boolean> promise = Futures.promise(); ProjectLogger.log( "ElasticSearchTcpImpl:update: method started at ==" + startTime + " for index " + index, LoggerEnum.PERF_LOG.name()); if (!StringUtils.isBlank(index) && !StringUtils.isBlank(identifier) && data != null) { try { UpdateResponse response = ConnectionManager.getClient().prepareUpdate(index, _DOC, identifier).setDoc(data).get(); ProjectLogger.log( "ElasticSearchTcpImpl:update: " + "updated response==" + response.getResult().name(), LoggerEnum.INFO.name()); if (response.getResult().name().equals("UPDATED")) { ProjectLogger.log( "ElasticSearchTcpImpl:update: method end ==" + " for index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(true); return promise.future(); } else { ProjectLogger.log( "ElasticSearchTcpImpl:update: update was not success:" + response.getResult(), LoggerEnum.INFO.name()); } } catch (Exception e) { ProjectLogger.log( "ElasticSearchTcpImpl:update: exception occured:" + e.getMessage(), LoggerEnum.ERROR.name()); promise.failure(e); } } else { ProjectLogger.log( "ElasticSearchTcpImpl:update: Requested data is invalid.", LoggerEnum.INFO.name()); } ProjectLogger.log( "ElasticSearchTcpImpl:update: method end ==" + " for Index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(false); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testUpdateDataFailureWithoutIdentifier() { Map<String, Object> innermap = new HashMap<>(); innermap.put("courseName", "Updated Course Name"); innermap.put("organisationId", "updatedOrgId"); Future<Boolean> response = esService.update(INDEX_NAME, null, innermap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpdateDataFailureWithEmptyMap() { Map<String, Object> innermap = new HashMap<>(); Future<Boolean> response = esService.update(INDEX_NAME, (String) chemistryMap.get("courseId"), innermap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpdateDataFailureWithNullMap() { Future<Boolean> response = esService.update(INDEX_NAME, (String) chemistryMap.get("courseId"), null); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpdateDataSuccess() { Map<String, Object> innermap = new HashMap<>(); innermap.put("courseName", "Updated course name"); innermap.put("organisationId", "updatedOrgId"); GetRequestBuilder grb = mock(GetRequestBuilder.class); GetResponse getResponse = mock(GetResponse.class); when(client.prepareGet( Mockito.anyString(), Mockito.anyString(), Mockito.eq((String) chemistryMap.get("courseId")))) .thenReturn(grb); when(grb.get()).thenReturn(getResponse); when(getResponse.getSource()).thenReturn(innermap); Future<Boolean> responseF = esService.update(INDEX_NAME, (String) chemistryMap.get("courseId"), innermap); boolean response = (boolean) ElasticSearchHelper.getResponseFromFuture(responseF); assertTrue(response); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Boolean> upsert(String index, String identifier, Map<String, Object> data) { long startTime = System.currentTimeMillis(); Promise<Boolean> promise = Futures.promise(); ProjectLogger.log( "ElasticSearchTcpImpl:upsert: method started at ==" + startTime + " for INdex " + index, LoggerEnum.PERF_LOG.name()); if (!StringUtils.isBlank(index) && !StringUtils.isBlank(identifier) && data != null && data.size() > 0) { IndexRequest indexRequest = new IndexRequest(index, _DOC, identifier).source(data); UpdateRequest updateRequest = new UpdateRequest(index, _DOC, identifier).doc(data).upsert(indexRequest); UpdateResponse response = null; try { response = ConnectionManager.getClient().update(updateRequest).get(); } catch (InterruptedException | ExecutionException e) { ProjectLogger.log("ElasticSearchTcpImpl:upsert: error occured == " + e.getMessage(), e); promise.success(false); return promise.future(); } ProjectLogger.log( "ElasticSearchTcpImpl:upsert: updated response==" + response.getResult().name(), LoggerEnum.INFO.name()); if (ElasticSearchHelper.upsertResults.contains(response.getResult().name())) { ProjectLogger.log( "ElasticSearchTcpImpl:upsert: method end ==" + " for index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(true); return promise.future(); } } else { ProjectLogger.log( "ElasticSearchTcpImpl:upsert: Requested data is invalid.", LoggerEnum.INFO.name()); promise.success(false); } ProjectLogger.log( "ElasticSearchTcpImpl:upsert: method end ==" + " for index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testUpsertDataFailureWithoutIdentifier() { Map<String, Object> innermap = new HashMap<>(); innermap.put("courseName", "Updated Course Name"); innermap.put("organisationId", "updatedOrgId"); Future<Boolean> response = esService.upsert(INDEX_NAME, null, innermap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpsertDataFailureWithoutIndex() { Map<String, Object> innermap = new HashMap<>(); innermap.put("courseName", "Updated Course Name"); innermap.put("organisationId", "updatedOrgId"); Future<Boolean> response = esService.upsert(null, (String) chemistryMap.get("courseId"), innermap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpsertDataFailureWithEmptyMap() { Map<String, Object> innermap = new HashMap<>(); Future<Boolean> response = esService.upsert(INDEX_NAME, (String) chemistryMap.get("courseId"), innermap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertFalse(result); }
@Test public void testUpsertDataSuccess() { Map<String, Object> data = new HashMap<String, Object>(); data.put("test", "test"); Future<Boolean> response = esService.upsert(INDEX_NAME, "test-12349", data); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(true, result); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<String> save(String index, String identifier, Map<String, Object> data) { long startTime = System.currentTimeMillis(); Promise<String> promise = Futures.promise(); ProjectLogger.log( "ElasticSearchTcpImpl:save: method started at ==" + startTime + " for Index " + index, LoggerEnum.PERF_LOG.name()); if (StringUtils.isBlank(identifier) || StringUtils.isBlank(index)) { ProjectLogger.log( "ElasticSearchTcpImpl:save: Identifier value is null or empty ,not able to save data.", LoggerEnum.ERROR.name()); promise.success("ERROR"); return promise.future(); } try { data.put("identifier", identifier); IndexResponse response = ConnectionManager.getClient().prepareIndex(index, _DOC, identifier).setSource(data).get(); ProjectLogger.log( "ElasticSearchTcpImpl:save: " + "Save value==" + response.getId() + " " + response.status(), LoggerEnum.INFO.name()); ProjectLogger.log( "ElasticSearchTcpImpl:save: method end at ==" + System.currentTimeMillis() + " for INdex " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(response.getId()); return promise.future(); } catch (Exception e) { ProjectLogger.log( "ElasticSearchTcpImpl:save: Error while saving index " + index + " id : " + identifier + " with error :" + e, LoggerEnum.INFO.name()); ProjectLogger.log( "ElasticSearchTcpImpl:save: method end at ==" + System.currentTimeMillis() + " for Index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(""); } return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testSaveDataFailureWithoutIndexName() { Future<String> response = esService.save("", (String) chemistryMap.get("courseId"), chemistryMap); String result = (String) ElasticSearchHelper.getResponseFromFuture(response); assertEquals("ERROR", result); }
@Test public void testCreateDataSuccess() { mockRulesForInsert(); esService.save(INDEX_NAME, (String) chemistryMap.get("courseId"), chemistryMap); assertNotNull(chemistryMap.get("courseId")); esService.save(INDEX_NAME, (String) physicsMap.get("courseId"), physicsMap); assertNotNull(physicsMap.get("courseId")); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Map<String, Object>> getDataByIdentifier(String index, String identifier) { long startTime = System.currentTimeMillis(); Promise<Map<String, Object>> promise = Futures.promise(); ProjectLogger.log( "ElasticSearchTcpImpl:getDataByIdentifier: method started at ==" + startTime + " for index " + index, LoggerEnum.PERF_LOG.name()); GetResponse response = null; if (StringUtils.isBlank(index) || StringUtils.isBlank(identifier)) { ProjectLogger.log( "ElasticSearchTcpImpl:getDataByIdentifier: Invalid request is coming.", LoggerEnum.INFO.name()); promise.success(new HashMap<>()); return promise.future(); } else { response = ConnectionManager.getClient().prepareGet(index, _DOC, identifier).get(); } if (response == null || null == response.getSource()) { promise.success(new HashMap<>()); return promise.future(); } ProjectLogger.log( "ElasticSearchTcpImpl:getDataByIdentifier: method " + " for index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(response.getSource()); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testGetDataByIdentifierFailureByEmptyIdentifier() { Future<Map<String, Object>> responseMap = esService.getDataByIdentifier(INDEX_NAME, ""); Map<String, Object> response = (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(responseMap); assertEquals(0, response.size()); }
@Test public void testGetByIdentifierSuccess() { Future<Map<String, Object>> responseMapF = esService.getDataByIdentifier(INDEX_NAME, (String) chemistryMap.get("courseId")); Map<String, Object> responseMap = (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(responseMapF); assertEquals(responseMap.get("courseId"), chemistryMap.get("courseId")); }
@Test public void testGetByIdentifierFailureWithoutIndex() { try { esService.getDataByIdentifier(null, (String) chemistryMap.get("courseId")); } catch (ProjectCommonException ex) { assertEquals(ResponseCode.SERVER_ERROR.getResponseCode(), ex.getResponseCode()); } }
@Test public void testGetByIdentifierFailureWithoutTypeAndIndexIdentifier() { try { esService.getDataByIdentifier(null, ""); } catch (ProjectCommonException ex) { assertEquals(ResponseCode.SERVER_ERROR.getResponseCode(), ex.getResponseCode()); } }
@Test public void testGetDataByIdentifierFailureWithoutIdentifier() { Future<Map<String, Object>> responseMap = esService.getDataByIdentifier(INDEX_NAME, ""); Map<String, Object> map = (Map<String, Object>) ElasticSearchHelper.getResponseFromFuture(responseMap); assertEquals(0, map.size()); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Boolean> delete(String index, String identifier) { long startTime = System.currentTimeMillis(); Promise<Boolean> promise = Futures.promise(); ProjectLogger.log( "ElasticSearchTcpImpl:delete: method started at ==" + startTime, LoggerEnum.PERF_LOG.name()); DeleteResponse deleteResponse = null; if (!StringUtils.isBlank(index) && !StringUtils.isBlank(identifier)) { try { deleteResponse = ConnectionManager.getClient().prepareDelete(index, _DOC, identifier).get(); ProjectLogger.log( "ElasticSearchTcpImpl:delete: info ==" + deleteResponse.getResult().name() + " " + deleteResponse.getId(), LoggerEnum.INFO.name()); } catch (Exception e) { promise.failure(e); ProjectLogger.log( "ElasticSearchTcpImpl:delete: error occured for index and identifier == " + index + " and " + identifier + " with error " + e.getMessage(), e); } } else { ProjectLogger.log( "ElasticSearchTcpImpl:delete: Data can not be deleted due to invalid input.", LoggerEnum.INFO.name()); promise.success(false); return promise.future(); } ProjectLogger.log( "ElasticSearchTcpImpl:delete: method end ==" + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); promise.success(deleteResponse.getResult().name().equalsIgnoreCase("DELETED")); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testRemoveDataSuccessByIdentifier() { Future<Boolean> response = esService.delete(INDEX_NAME, (String) chemistryMap.get("courseId")); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(true, result); }
@Test public void testRemoveDataFailureByIdentifierEmpty() { Future<Boolean> response = esService.delete(INDEX_NAME, ""); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(false, result); } |
JavaMigrationResolver implements MigrationResolver { ResolvedMigration extractMigrationInfo(JavaMigration javaMigration) { Integer checksum = null; if (javaMigration instanceof MigrationChecksumProvider) { MigrationChecksumProvider checksumProvider = (MigrationChecksumProvider) javaMigration; checksum = checksumProvider.getChecksum(); } MigrationVersion version; String description; if (javaMigration instanceof MigrationInfoProvider) { MigrationInfoProvider infoProvider = (MigrationInfoProvider) javaMigration; version = infoProvider.getVersion(); description = infoProvider.getDescription(); if (!StringUtils.hasText(description)) { throw new CassandraMigrationException("Missing description for migration " + version); } } else { Pair<MigrationVersion, String> info = MigrationInfoHelper.extractVersionAndDescription( ClassUtils.getShortName(javaMigration.getClass()), "V", "__", ""); version = info.getLeft(); description = info.getRight(); } String script = javaMigration.getClass().getName(); ResolvedMigration resolvedMigration = new ResolvedMigration(); resolvedMigration.setVersion(version); resolvedMigration.setDescription(description); resolvedMigration.setScript(script); resolvedMigration.setChecksum(checksum); resolvedMigration.setType(MigrationType.JAVA_DRIVER); return resolvedMigration; } JavaMigrationResolver(ClassLoader classLoader, ScriptsLocation location); List<ResolvedMigration> resolveMigrations(); } | @Test public void explicitInfo() { JavaMigrationResolver jdbcMigrationResolver = new JavaMigrationResolver(Thread.currentThread().getContextClassLoader(), null); ResolvedMigration migrationInfo = jdbcMigrationResolver.extractMigrationInfo(new Version3dot5()); assertEquals("3.5", migrationInfo.getVersion().toString()); assertEquals("Three Dot Five", migrationInfo.getDescription()); assertEquals(35, migrationInfo.getChecksum().intValue()); }
@Test public void conventionOverConfiguration() { JavaMigrationResolver jdbcMigrationResolver = new JavaMigrationResolver(Thread.currentThread().getContextClassLoader(), null); ResolvedMigration migrationInfo = jdbcMigrationResolver.extractMigrationInfo(new V2__InterfaceBasedMigration()); assertEquals("2", migrationInfo.getVersion().toString()); assertEquals("InterfaceBasedMigration", migrationInfo.getDescription()); assertNull(migrationInfo.getChecksum()); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Boolean> healthCheck() { Promise<Boolean> promise = Futures.promise(); boolean indexResponse = false; try { indexResponse = ConnectionManager.getClient() .admin() .indices() .exists(Requests.indicesExistsRequest(ProjectUtil.EsType.user.getTypeName())) .get() .isExists(); } catch (Exception e) { ProjectLogger.log("ElasticSearchTcpImpl:healthCheck: error " + e.getMessage(), e); promise.failure(e); } promise.success(indexResponse); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testHealthCheckSuccess() { Future<Boolean> response = esService.healthCheck(); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(true, result); } |
ElasticSearchTcpImpl implements ElasticSearchService { @Override public Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList) { Promise<Boolean> promise = Futures.promise(); long startTime = System.currentTimeMillis(); ProjectLogger.log( "ElasticSearchTcpImpl:bulkInsert: method started at ==" + startTime + " for index " + index, LoggerEnum.PERF_LOG.name()); promise.success(true); try { BulkProcessor bulkProcessor = BulkProcessor.builder( ConnectionManager.getClient(), new BulkProcessor.Listener() { @Override public void beforeBulk(long executionId, BulkRequest request) {} @Override public void afterBulk( long executionId, BulkRequest request, BulkResponse response) { Iterator<BulkItemResponse> bulkResponse = response.iterator(); if (bulkResponse != null) { while (bulkResponse.hasNext()) { BulkItemResponse bResponse = bulkResponse.next(); ProjectLogger.log( "ElasticSearchTcpImpl:bulkInsert: " + "Bulk insert api response===" + bResponse.getId() + " " + bResponse.isFailed(), LoggerEnum.INFO.name()); } } } @Override public void afterBulk( long executionId, BulkRequest request, Throwable failure) { ProjectLogger.log( "ElasticSearchTcpImpl:bulkInsert: Bulk upload error block with error " + failure, LoggerEnum.INFO.name()); } }) .setBulkActions(10000) .setConcurrentRequests(0) .build(); for (Map<String, Object> map : dataList) { map.put(JsonKey.IDENTIFIER, map.get(JsonKey.ID)); IndexRequest request = new IndexRequest(index, _DOC, (String) map.get(JsonKey.IDENTIFIER)).source(map); bulkProcessor.add(request); } bulkProcessor.flush(); bulkProcessor.close(); ConnectionManager.getClient().admin().indices().prepareRefresh().get(); } catch (Exception e) { promise.success(false); ProjectLogger.log("ElasticSearchTcpImpl:bulkInsert: Bulk upload error " + e.getMessage(), e); } ProjectLogger.log( "ElasticSearchTcpImpl:bulkInsert: method end at ==" + System.currentTimeMillis() + " for index " + index + " ,Total time elapsed = " + ElasticSearchHelper.calculateEndTime(startTime), LoggerEnum.PERF_LOG.name()); return promise.future(); } @Override Future<String> save(String index, String identifier, Map<String, Object> data); @Override Future<Map<String, Object>> getDataByIdentifier(String index, String identifier); @Override Future<Boolean> update(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> upsert(String index, String identifier, Map<String, Object> data); @Override Future<Boolean> delete(String index, String identifier); @Override Future<Map<String, Object>> search(SearchDTO searchDTO, String index); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds(
List<String> ids, List<String> fields, String index); @Override Future<Boolean> bulkInsert(String index, List<Map<String, Object>> dataList); @Override Future<Boolean> healthCheck(); static final int WAIT_TIME; static Timeout timeout; } | @Test public void testBulkInsertDataSuccess() { Map<String, Object> data = new HashMap<String, Object>(); data.put("test1", "test"); data.put("test2", "manzarul"); List<Map<String, Object>> listOfMap = new ArrayList<Map<String, Object>>(); listOfMap.add(data); Future<Boolean> response = esService.bulkInsert(INDEX_NAME, listOfMap); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(true, result); } |
ConnectionManager { private static boolean initialiseConnection() { try { if (initialiseConnectionFromEnv()) { ProjectLogger.log("value found under system variable.", LoggerEnum.INFO.name()); return true; } return initialiseConnectionFromPropertiesFile(cluster, hostName, port); } catch (Exception e) { ProjectLogger.log("Error while initialising elastic search connection", e); return false; } } private ConnectionManager(); static TransportClient getClient(); static RestHighLevelClient getRestClient(); static boolean initialiseConnectionFromPropertiesFile(
String cluster, String hostName, String port); static void closeClient(); static void registerShutDownHook(); } | @Test public void testInitialiseConnection() { TransportClient client = ConnectionManager.getClient(); Assert.assertNotNull(client); } |
ConnectionManager { public static RestHighLevelClient getRestClient() { if (restClient == null) { ProjectLogger.log( "ConnectionManager:getRestClient eLastic search rest clinet is null " + client, LoggerEnum.INFO.name()); initialiseRestClientConnection(); ProjectLogger.log( "ConnectionManager:getRestClient after calling initialiseRestClientConnection ES client value " + client, LoggerEnum.INFO.name()); } return restClient; } private ConnectionManager(); static TransportClient getClient(); static RestHighLevelClient getRestClient(); static boolean initialiseConnectionFromPropertiesFile(
String cluster, String hostName, String port); static void closeClient(); static void registerShutDownHook(); } | @Test public void testGetRestClientNull() { RestHighLevelClient client = ConnectionManager.getRestClient(); Assert.assertNull(client); } |
ConnectionManager { public static boolean initialiseConnectionFromPropertiesFile( String cluster, String hostName, String port) { try { String[] splitedHost = hostName.split(","); for (String val : splitedHost) { host.add(val); } String[] splitedPort = port.split(","); for (String val : splitedPort) { ports.add(Integer.parseInt(val)); } boolean response = createClient(cluster, host); ProjectLogger.log( "ES Connection Established from Properties file Cluster " + cluster + " host " + hostName + " port " + port + " Response " + response, LoggerEnum.INFO.name()); } catch (Exception e) { ProjectLogger.log("Error while initialising connection From Properties File", e); return false; } return true; } private ConnectionManager(); static TransportClient getClient(); static RestHighLevelClient getRestClient(); static boolean initialiseConnectionFromPropertiesFile(
String cluster, String hostName, String port); static void closeClient(); static void registerShutDownHook(); } | @Test @Ignore public void testInitialiseConnectionFromPropertiesFile() { boolean response = ConnectionManager.initialiseConnectionFromPropertiesFile("test", "localhost", "9200"); Assert.assertTrue(response); }
@Test public void testInitialiseConnectionFromPropertiesFileFailWithEmpty() { boolean response = ConnectionManager.initialiseConnectionFromPropertiesFile("test", "localhost", ""); Assert.assertFalse(response); }
@Test public void testInitialiseConnectionFromPropertiesFileFailWithNull() { boolean response = ConnectionManager.initialiseConnectionFromPropertiesFile("test", "localhost", null); Assert.assertFalse(response); } |
ConnectionManager { public static void closeClient() { client.close(); } private ConnectionManager(); static TransportClient getClient(); static RestHighLevelClient getRestClient(); static boolean initialiseConnectionFromPropertiesFile(
String cluster, String hostName, String port); static void closeClient(); static void registerShutDownHook(); } | @Test public void testCloseConnection () { ConnectionManager.closeClient(); Assert.assertTrue(true); } |
CompositeMigrationResolver implements MigrationResolver { public List<ResolvedMigration> resolveMigrations() { if (availableMigrations == null) { availableMigrations = doFindAvailableMigrations(); } return availableMigrations; } CompositeMigrationResolver(
ClassLoader classLoader,
ScriptsLocations locations,
String encoding,
MigrationResolver... customMigrationResolvers); List<ResolvedMigration> resolveMigrations(); } | @Test public void resolveMigrationsMultipleLocations() { MigrationResolver migrationResolver = new CompositeMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocations( "migration/subdir/dir2", "migration.outoforder", "migration/subdir/dir1"), "UTF-8"); Collection<ResolvedMigration> migrations = migrationResolver.resolveMigrations(); List<ResolvedMigration> migrationList = new ArrayList<ResolvedMigration>(migrations); assertEquals(3, migrations.size()); assertEquals("First", migrationList.get(0).getDescription()); assertEquals("Late arrival", migrationList.get(1).getDescription()); assertEquals("Add contents table", migrationList.get(2).getDescription()); } |
KeyCloakServiceImpl implements SSOManager { @Override public String getUsernameById(String userId) { String fedUserId = getFederatedUserId(userId); try { UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); return ur.getUsername(); } catch (Exception e) { ProjectLogger.log( "KeyCloakServiceImpl:getUsernameById: User not found for userId = " + userId + " error message = " + e.getMessage(), e); } ProjectLogger.log( "KeyCloakServiceImpl:getUsernameById: User not found for userId = " + userId, LoggerEnum.INFO.name()); return ""; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testGetUsernameById() { String result = keyCloakService.getUsernameById("1234-567-890"); Assert.assertNotNull(result); } |
KeyCloakServiceImpl implements SSOManager { @Override public String updateUser(Map<String, Object> request) { String userId = (String) request.get(JsonKey.USER_ID); String fedUserId = getFederatedUserId(userId); UserRepresentation ur = null; UserResource resource = null; boolean needTobeUpdate = false; try { resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); ur = resource.toRepresentation(); } catch (Exception e) { ProjectUtil.createAndThrowInvalidUserDataException(); } if (isNotNull(request.get(JsonKey.FIRST_NAME))) { needTobeUpdate = true; ur.setFirstName((String) request.get(JsonKey.FIRST_NAME)); } if (isNotNull(request.get(JsonKey.LAST_NAME))) { needTobeUpdate = true; ur.setLastName((String) request.get(JsonKey.LAST_NAME)); } if (isNotNull(request.get(JsonKey.EMAIL))) { needTobeUpdate = true; ur.setEmail((String) request.get(JsonKey.EMAIL)); ur.setEmailVerified(false); Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("false"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } if (!StringUtils.isBlank((String) request.get(JsonKey.PHONE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add((String) request.get(JsonKey.PHONE)); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.PHONE, list); ur.setAttributes(map); } if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = new ArrayList<>(); list.add(PropertiesCache.getInstance().getProperty("sunbird_default_country_code")); if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { list.add(0, (String) request.get(JsonKey.COUNTRY_CODE)); } map.put(JsonKey.COUNTRY_CODE, list); ur.setAttributes(map); } try { if (needTobeUpdate) { resource.update(ur); } } catch (Exception ex) { ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testUserUpdateTestSuccessWithAllData() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); String result = keyCloakService.updateUser(request); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutProvider() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.COUNTRY_CODE, "+91"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); String result = keyCloakService.updateUser(request); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutProviderAndCountryCode() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); request.put(JsonKey.FIRST_NAME, userName); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USERNAME, userName); String result = keyCloakService.updateUser(request); Assert.assertNotNull(result); }
@Test public void testUpdateUserSuccessWithoutAnyField() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String result = keyCloakService.updateUser(request); Assert.assertNotNull(result); } |
KeyCloakServiceImpl implements SSOManager { @Override public String deactivateUser(Map<String, Object> request) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, false); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test(expected = ProjectCommonException.class) public void testDeactivateUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); request.put(JsonKey.FIRST_NAME, userName); keyCloakService.deactivateUser(request); } |
KeyCloakServiceImpl implements SSOManager { @Override public String removeUser(Map<String, Object> request) { Keycloak keycloak = KeyCloakConnectionProvider.getConnection(); String userId = (String) request.get(JsonKey.USER_ID); try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNotNull(resource)) { resource.remove(); } } catch (Exception ex) { ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test(expected = ProjectCommonException.class) public void testRemoveUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); keyCloakService.removeUser(request); } |
KeyCloakServiceImpl implements SSOManager { @Override public String verifyToken(String accessToken) { return verifyToken(accessToken, null); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test(expected = ProjectCommonException.class) public void testVerifyTokenSuccess() { keyCloakService.verifyToken( "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICI5emhhVnZDbl81OEtheHpldHBzYXNZQ2lEallkemJIX3U2LV93SDk4SEc0In0.eyJqdGkiOiI5ZmQzNzgzYy01YjZmLTQ3OWQtYmMzYy0yZWEzOGUzZmRmYzgiLCJleHAiOjE1MDUxMTQyNDYsIm5iZiI6MCwiaWF0IjoxNTA1MTEzNjQ2LCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvYXV0aC9yZWFsbXMvbWFzdGVyIiwiYXVkIjoic2VjdXJpdHktYWRtaW4tY29uc29sZSIsInN1YiI6ImIzYTZkMTY4LWJjZmQtNDE2MS1hYzVmLTljZjYyODIyNzlmMyIsInR5cCI6IkJlYXJlciIsImF6cCI6InNlY3VyaXR5LWFkbWluLWNvbnNvbGUiLCJub25jZSI6ImMxOGVlMDM2LTAyMWItNGVlZC04NWVhLTc0MjMyYzg2ZmI4ZSIsImF1dGhfdGltZSI6MTUwNTExMzY0Niwic2Vzc2lvbl9zdGF0ZSI6ImRiZTU2NDlmLTY4MDktNDA3NS05Njk5LTVhYjIyNWMwZTkyMiIsImFjciI6IjEiLCJhbGxvd2VkLW9yaWdpbnMiOltdLCJyZXNvdXJjZV9hY2Nlc3MiOnt9LCJuYW1lIjoiTWFuemFydWwgaGFxdWUiLCJwcmVmZXJyZWRfdXNlcm5hbWUiOiJ0ZXN0MTIzNDU2NyIsImdpdmVuX25hbWUiOiJNYW56YXJ1bCBoYXF1ZSIsImVtYWlsIjoidGVzdDEyM0B0LmNvbSJ9.Xdjqe16MSkiR94g-Uj_pVZ2L3gnIdKpkJ6aB82W_w_c3yEmx1mXYBdkxe4zMz3ks4OX_PWwSFEbJECHcnujUwF6Ula0xtXTfuESB9hFyiWHtVAhuh5UlCCwPnsihv5EqK6u-Qzo0aa6qZOiQK3Zo7FLpnPUDxn4yHyo3mRZUiWf76KTl8PhSMoXoWxcR2vGW0b-cPixILTZPV0xXUZoozCui70QnvTgOJDWqr7y80EWDkS4Ptn-QM3q2nJlw63mZreOG3XTdraOlcKIP5vFK992dyyHlYGqWVzigortS9Ah4cprFVuLlX8mu1cQvqHBtW-0Dq_JlcTMaztEnqvJ6XA"); } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean addUserLoginTime(String userId) { boolean response = true; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); if (map == null) { map = new HashMap<>(); } List<String> currentLogTime = map.get(JsonKey.CURRENT_LOGIN_TIME); if (currentLogTime == null || currentLogTime.isEmpty()) { currentLogTime = new ArrayList<>(); currentLogTime.add(Long.toString(System.currentTimeMillis())); } else { list.add(currentLogTime.get(0)); currentLogTime.clear(); currentLogTime.add(0, Long.toString(System.currentTimeMillis())); } map.put(JsonKey.CURRENT_LOGIN_TIME, currentLogTime); map.put(JsonKey.LAST_LOGIN_TIME, list); ur.setAttributes(map); resource.update(ur); } catch (Exception e) { ProjectLogger.log(e.getMessage(), e); response = false; } return response; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testAddUserLoginTimeSuccess() { boolean response = keyCloakService.addUserLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertEquals(true, response); } |
CompositeMigrationResolver implements MigrationResolver { static Collection<ResolvedMigration> collectMigrations( Collection<MigrationResolver> migrationResolvers) { Set<ResolvedMigration> migrations = new HashSet<ResolvedMigration>(); for (MigrationResolver migrationResolver : migrationResolvers) { migrations.addAll(migrationResolver.resolveMigrations()); } return migrations; } CompositeMigrationResolver(
ClassLoader classLoader,
ScriptsLocations locations,
String encoding,
MigrationResolver... customMigrationResolvers); List<ResolvedMigration> resolveMigrations(); } | @Test public void collectMigrations() { MigrationResolver migrationResolver = new MigrationResolver() { public List<ResolvedMigration> resolveMigrations() { List<ResolvedMigration> migrations = new ArrayList<ResolvedMigration>(); migrations.add( createTestMigration( MigrationType.JAVA_DRIVER, "1", "Description", "Migration1", 123)); migrations.add( createTestMigration( MigrationType.JAVA_DRIVER, "1", "Description", "Migration1", 123)); migrations.add( createTestMigration(MigrationType.CQL, "2", "Description2", "Migration2", 1234)); return migrations; } }; Collection<MigrationResolver> migrationResolvers = new ArrayList<MigrationResolver>(); migrationResolvers.add(migrationResolver); Collection<ResolvedMigration> migrations = CompositeMigrationResolver.collectMigrations(migrationResolvers); assertEquals(2, migrations.size()); } |
KeyCloakServiceImpl implements SSOManager { @Override public String getLastLoginTime(String userId) { String lastLoginTime = null; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = map.get(JsonKey.LAST_LOGIN_TIME); if (list != null && !list.isEmpty()) { lastLoginTime = list.get(0); } } catch (Exception e) { ProjectLogger.log(e.getMessage(), e); } return lastLoginTime; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testGetLastLoginTimeSuccess() { String lastLoginTime = keyCloakService.getLastLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertNull(lastLoginTime); } |
KeyCloakServiceImpl implements SSOManager { @Override public String activateUser(Map<String, Object> request) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, true); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testActivateUserFailureWithEmptyUserId() { Map<String, Object> reqMap = new HashMap<>(); reqMap.put(JsonKey.USER_ID, ""); try { keyCloakService.activateUser(reqMap); } catch (ProjectCommonException e) { Assert.assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); Assert.assertEquals(ResponseCode.invalidUsrData.getErrorMessage(), e.getMessage()); Assert.assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); } } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean isEmailVerified(String userId) { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNull(resource)) { return false; } return resource.toRepresentation().isEmailVerified(); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testIsEmailVerifiedSuccess() { boolean response = keyCloakService.isEmailVerified(userId.get(JsonKey.USER_ID)); Assert.assertEquals(false, response); } |
KeyCloakServiceImpl implements SSOManager { @Override public String setEmailVerifiedTrue(String userId) { updateEmailVerifyStatus(userId, true); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testSetEmailVerifiedSuccessWithVerifiedTrue() { String response = keyCloakService.setEmailVerifiedTrue(userId.get(JsonKey.USER_ID)); Assert.assertEquals(JsonKey.SUCCESS, response); } |
KeyCloakServiceImpl implements SSOManager { @Override public String syncUserData(Map<String, Object> request) { String userId = (String) request.get(JsonKey.USER_ID); String fedUserId = getFederatedUserId(userId); UserRepresentation ur = null; UserResource resource = null; boolean needTobeUpdate = false; try { resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); ur = resource.toRepresentation(); } catch (Exception e) { ProjectUtil.createAndThrowInvalidUserDataException(); } if (isNotNull(request.get(JsonKey.FIRST_NAME))) { needTobeUpdate = true; ur.setFirstName((String) request.get(JsonKey.FIRST_NAME)); } if (isNotNull(request.get(JsonKey.LAST_NAME))) { needTobeUpdate = true; ur.setLastName((String) request.get(JsonKey.LAST_NAME)); } if (isNotNull(request.get(JsonKey.EMAIL))) { needTobeUpdate = true; ur.setEmail((String) request.get(JsonKey.EMAIL)); } ProjectLogger.log( "check user email is verified or not ,resource.toRepresentation().isEmailVerified() :" + resource.toRepresentation().isEmailVerified() + " for userId :" + userId); if (!resource.toRepresentation().isEmailVerified()) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("false"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } else { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add("true"); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list); ur.setAttributes(map); } if (isNotNull(request.get(JsonKey.LOGIN_ID))) { needTobeUpdate = true; ur.setUsername((String) request.get(JsonKey.LOGIN_ID)); } if (!StringUtils.isBlank((String) request.get(JsonKey.PHONE))) { needTobeUpdate = true; Map<String, List<String>> map = ur.getAttributes(); List<String> list = new ArrayList<>(); list.add((String) request.get(JsonKey.PHONE)); if (map == null) { map = new HashMap<>(); } map.put(JsonKey.PHONE, list); ur.setAttributes(map); } Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = new ArrayList<>(); list.add(PropertiesCache.getInstance().getProperty("sunbird_default_country_code")); map.put(JsonKey.COUNTRY_CODE, list); if (!StringUtils.isBlank((String) request.get(JsonKey.COUNTRY_CODE))) { needTobeUpdate = true; list.add(0, (String) request.get(JsonKey.COUNTRY_CODE)); map.put(JsonKey.COUNTRY_CODE, list); } ur.setAttributes(map); try { if (needTobeUpdate) { resource.update(ur); } } catch (Exception ex) { ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testSyncUserDataSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.COUNTRY_CODE, "+91"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithoutCountryCode() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PROVIDER, "ntp"); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithoutProvider() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, userId.get(JsonKey.USER_ID)); String response = keyCloakService.syncUserData(request); Assert.assertEquals(JsonKey.SUCCESS, response); }
@Test public void testSyncUserDataSuccessWithInvalidUser() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USERNAME, userName); request.put(JsonKey.PASSWORD, "password"); request.put(JsonKey.FIRST_NAME, "A"); request.put(JsonKey.LAST_NAME, "B"); request.put(JsonKey.PHONE, "9870060000"); request.put(JsonKey.EMAIL, userName.substring(0, 10)); request.put(JsonKey.USER_ID, "xey123-23sss-cbdsgdgdg"); try { keyCloakService.syncUserData(request); } catch (ProjectCommonException e) { Assert.assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); Assert.assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); } } |
KeyCloakServiceImpl implements SSOManager { @Override public boolean doPasswordUpdate(String userId, String password) { boolean response = false; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation newCredential = new CredentialRepresentation(); newCredential.setValue(password); newCredential.setType(CredentialRepresentation.PASSWORD); newCredential.setTemporary(true); resource.resetPassword(newCredential); response = true; } catch (Exception ex) { ProjectLogger.log(ex.getMessage(), ex); } return response; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testDoPasswordUpdateSuccess() { boolean response = keyCloakService.doPasswordUpdate(userId.get(JsonKey.USER_ID), "password"); Assert.assertEquals(true, response); } |
KeyCloakServiceImpl implements SSOManager { private String getFederatedUserId(String userId) { return String.join( ":", "f", ProjectUtil.getConfigValue(JsonKey.SUNBIRD_KEYCLOAK_USER_FEDERATION_PROVIDER_ID), userId); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken); @Override boolean updatePassword(String userId, String password); @Override String updateUser(Map<String, Object> request); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request); @Override String deactivateUser(Map<String, Object> request); @Override String activateUser(Map<String, Object> request); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url); } | @Test public void testGetFederatedUserId() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException { KeyCloakServiceImpl.class.getDeclaredMethods(); Method m = KeyCloakServiceImpl.class.getDeclaredMethod("getFederatedUserId", String.class); m.setAccessible(true); SSOManager keyCloakService = SSOServiceFactory.getInstance(); String fedUserId = (String) m.invoke(keyCloakService, "userId"); Assert.assertEquals( "f:" + ProjectUtil.getConfigValue(JsonKey.SUNBIRD_KEYCLOAK_USER_FEDERATION_PROVIDER_ID) + ":userId", fedUserId); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.