Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV1Request(Request userRequest) { validateUserName(userRequest); validateCreateUserV3Request(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields( Map<String, Object> userMap, List<String> frameworkFields, List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues( Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest( Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); }### Answer: @Test public void testValidateUserNameFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.USERNAME, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV1Request(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.mandatoryParamsMissing.getErrorCode(), e.getCode()); } }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void removeDuplicateChar() { String val = Slug.removeDuplicateChars("ntpntest"); Assert.assertEquals("ntpes", val); }
### Question: 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); }### Answer: @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)); }); }
### Question: LogMaskServiceImpl implements DataMaskingService { public String maskPhone(String phone) { return phone.replaceAll("(^[^]{9}\|(?!^)\\G)[^]", "$1"); } String maskEmail(String email); String maskPhone(String phone); }### Answer: @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)); }); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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()); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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(); }### Answer: @Test public void generateOtpTest() { for (int i = 0; i < 10000; i++) { String code = OTPUtil.generateOtp(null); Assert.assertTrue(code.length() >= 4); } }
### Question: 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(); }### Answer: @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); } }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testGetInstance() { Assert.assertEquals( emailTemplateDao.getClass().getSimpleName(), EmailTemplateDaoImpl.getInstance().getClass().getSimpleName()); }
### Question: 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; }### Answer: @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()); }
### Question: 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); }### Answer: @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); } }
### Question: 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); }### Answer: @Test public void saveFeedInsertTest() { List<String> userIds = new ArrayList<>(); userIds.add("123-456-7890"); Response response = FeedUtil.saveFeed(getShadowUser(), userIds, null); Assert.assertNotNull(response); }
### Question: 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); }### Answer: @Test public void testInsert() { Response res = feedService.insert(getFeed(false), null); Assert.assertTrue( ((String) res.getResult().get(JsonKey.RESPONSE)).equalsIgnoreCase(JsonKey.SUCCESS)); }
### Question: 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); }### Answer: @Test public void testUpdate() { Response res = feedService.update(getFeed(true), null); Assert.assertTrue( ((String) res.getResult().get(JsonKey.RESPONSE)).equalsIgnoreCase(JsonKey.SUCCESS)); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: KeyManager { public static KeyData getPublicKey(String keyId) { return keyMap.get(keyId); } static void init(); static KeyData getPublicKey(String keyId); static PublicKey loadPublicKey(String key); }### Answer: @Test public void testGetPublicKey() { KeyData key = KeyManager.getPublicKey("keyId"); assertNull(key); }
### Question: EsClientFactory { private static ElasticSearchService getRestClient() { if (restClient == null) { synchronized (EsClientFactory.class) { if (restClient == null) { restClient = new ElasticSearchRestHighImpl(); } } } return restClient; } static ElasticSearchService getInstance(String type); }### Answer: @Test public void testGetRestClient() { ElasticSearchService service = EsClientFactory.getInstance("rest"); Assert.assertTrue(service instanceof ElasticSearchRestHighImpl); }
### Question: 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); }### Answer: @Test public void testInstanceNull() { ElasticSearchService service = EsClientFactory.getInstance("test"); Assert.assertNull(service); }
### Question: 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(); }### Answer: @Test public void passwordAuthTest() { PasswordAuthentication authentication = authenticator.getPasswordAuthentication(); Assert.assertEquals("test", authentication.getPassword()); }
### Question: 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(); }### Answer: @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()); }
### Question: 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; }### Answer: @Test public void testHealthCheckSuccess() { Future<Boolean> response = esService.healthCheck(); boolean result = (boolean) ElasticSearchHelper.getResponseFromFuture(response); assertEquals(true, result); }
### Question: 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(); }### Answer: @Test public void testInitialiseConnection() { TransportClient client = ConnectionManager.getClient(); Assert.assertNotNull(client); }
### Question: 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(); }### Answer: @Test public void testGetRestClientNull() { RestHighLevelClient client = ConnectionManager.getRestClient(); Assert.assertNull(client); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @Test public void testCloseConnection () { ConnectionManager.closeClient(); Assert.assertTrue(true); }
### Question: 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(); }### Answer: @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()); }
### Question: 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); }### Answer: @Test public void testGetUsernameById() { String result = keyCloakService.getUsernameById("1234-567-890"); Assert.assertNotNull(result); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test(expected = ProjectCommonException.class) public void testRemoveUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); keyCloakService.removeUser(request); }
### Question: 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(); }### Answer: @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()); }
### Question: 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); }### Answer: @Test public void testGetLastLoginTimeSuccess() { String lastLoginTime = keyCloakService.getLastLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertNull(lastLoginTime); }
### Question: 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); }### Answer: @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()); } }
### Question: 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); }### Answer: @Test public void testIsEmailVerifiedSuccess() { boolean response = keyCloakService.isEmailVerified(userId.get(JsonKey.USER_ID)); Assert.assertEquals(false, response); }
### Question: 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); }### Answer: @Test public void testSetEmailVerifiedSuccessWithVerifiedTrue() { String response = keyCloakService.setEmailVerifiedTrue(userId.get(JsonKey.USER_ID)); Assert.assertEquals(JsonKey.SUCCESS, response); }
### Question: 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); }### Answer: @Test public void testDoPasswordUpdateSuccess() { boolean response = keyCloakService.doPasswordUpdate(userId.get(JsonKey.USER_ID), "password"); Assert.assertEquals(true, response); }
### Question: 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); }### Answer: @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); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public boolean updatePassword(String userId, String password) { try { String fedUserId = getFederatedUserId(userId); UserResource ur = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation cr = new CredentialRepresentation(); cr.setType(CredentialRepresentation.PASSWORD); cr.setValue(password); ur.resetPassword(cr); return true; } catch (Exception e) { ProjectLogger.log( "KeyCloakServiceImpl:updatePassword: Exception occurred with error message = " + e, LoggerEnum.ERROR.name()); } return false; } 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); }### Answer: @Test public void testUpdatePassword() throws Exception { boolean updated = keyCloakService.updatePassword(userId.get(JsonKey.USER_ID), "password"); Assert.assertTrue(updated); }
### Question: RequestValidator { public static void validateClientId(String clientId) { if (StringUtils.isBlank(clientId)) { throw createExceptionInstance(ResponseCode.invalidClientId.getErrorCode()); } } private RequestValidator(); @SuppressWarnings("unchecked") static void validateUpdateContent(Request contentRequestDto); static void validateGetPageData(Request request); static void validateAddBatchCourse(Request courseRequest); static void validateGetBatchCourse(Request courseRequest); static void validateUpdateCourse(Request request); static void validatePublishCourse(Request request); static void validateDeleteCourse(Request request); static void validateCreateSection(Request request); static void validateUpdateSection(Request request); static void validateCreatePage(Request request); static void validateUpdatepage(Request request); static void validateUploadUser(Map<String, Object> reqObj); static void validateCreateBatchReq(Request request); static void validateUpdateCourseBatchReq(Request request); static void validateEnrolmentType(String enrolmentType); static void validateSyncRequest(Request request); static void validateUpdateSystemSettingsRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateClientIdFailureWithEmptyId() { try { RequestValidator.validateClientId(""); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientId.getErrorCode(), e.getCode()); } }
### Question: UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV3Request(Request userRequest) { validateCreateUserRequest(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); @SuppressWarnings("unchecked") void validateWebPages(Request request); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); void validateBulkUserData(Request userRequest); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields( Map<String, Object> userMap, List<String> frameworkFields, List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues( Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest( Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); }### Answer: @Test public void testValidateValidateCreateUserV3RequestSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "Password@1"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV3Request(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }
### Question: UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV1Request(Request userRequest) { validateUserName(userRequest); validateCreateUserV3Request(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); @SuppressWarnings("unchecked") void validateWebPages(Request request); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); void validateBulkUserData(Request userRequest); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields( Map<String, Object> userMap, List<String> frameworkFields, List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues( Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest( Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); }### Answer: @Test public void testValidateUserNameFailure() { Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.USERNAME, ""); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV1Request(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.mandatoryParamsMissing.getErrorCode(), e.getCode()); } }
### Question: Email { public boolean sendEmail(String fromEmail, String subject, String body, List<String> bccList) { boolean sentStatus = true; try { Session session = getSession(); MimeMessage message = new MimeMessage(session); addRecipient(message, Message.RecipientType.BCC, bccList); setMessageAttribute(message, fromEmail, subject, body); sentStatus = sendEmail(session, message); } catch (Exception e) { sentStatus = false; logger.error("SendMail:sendMail: Exception occurred with message = " + e.getMessage(), e); } return sentStatus; } 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(); }### Answer: @Test public void sendEmailTest() throws MessagingException { List<String> to = new ArrayList<String>(); to.add("[email protected]"); to.add("[email protected]"); emailService.sendEmail("[email protected]", subject, "Hi how are you", to); List<Message> inbox = Mailbox.get("[email protected]"); Assert.assertTrue(inbox.size() > 0); Assert.assertEquals(subject, inbox.get(0).getSubject()); } @Test public void sendEmailTOBCC() throws MessagingException{ List<String> bcc = new ArrayList<String>(); bcc.add("[email protected]"); emailService.sendEmail("[email protected]", subject, "Bcc email test body", bcc); List<Message> inbox = Mailbox.get("[email protected]"); Assert.assertTrue(inbox.size() > 0); Assert.assertEquals(subject, inbox.get(0).getSubject()); }
### Question: CqlMigrationResolver implements MigrationResolver { public List<ResolvedMigration> resolveMigrations() { List<ResolvedMigration> migrations = new ArrayList<>(); Resource[] resources = scanner.scanForResources(location, CQL_MIGRATION_PREFIX, CQL_MIGRATION_SUFFIX); for (Resource resource : resources) { ResolvedMigration resolvedMigration = extractMigrationInfo(resource); resolvedMigration.setPhysicalLocation(resource.getLocationOnDisk()); resolvedMigration.setExecutor(new CqlMigrationExecutor(resource, encoding)); migrations.add(resolvedMigration); } Collections.sort(migrations, new ResolvedMigrationComparator()); return migrations; } CqlMigrationResolver(ClassLoader classLoader, ScriptsLocation location, String encoding); List<ResolvedMigration> resolveMigrations(); }### Answer: @Test public void resolveMigrations() { CqlMigrationResolver cqlMigrationResolver = new CqlMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocation("migration/subdir"), "UTF-8"); Collection<ResolvedMigration> migrations = cqlMigrationResolver.resolveMigrations(); assertEquals(3, migrations.size()); List<ResolvedMigration> migrationList = new ArrayList<ResolvedMigration>(migrations); assertEquals("1", migrationList.get(0).getVersion().toString()); assertEquals("1.1", migrationList.get(1).getVersion().toString()); assertEquals("2.0", migrationList.get(2).getVersion().toString()); assertEquals("dir1/V1__First.cql", migrationList.get(0).getScript()); assertEquals("V1_1__Populate_table.cql", migrationList.get(1).getScript()); assertEquals("dir2/V2_0__Add_contents_table.cql", migrationList.get(2).getScript()); } @Test(expected = CassandraMigrationException.class) public void resolveMigrationsNonExisting() { CqlMigrationResolver cqlMigrationResolver = new CqlMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocation("non/existing"), "UTF-8"); cqlMigrationResolver.resolveMigrations(); }
### Question: CqlMigrationResolver implements MigrationResolver { String extractScriptName(Resource resource) { if (location.getPath().isEmpty()) { return resource.getLocation(); } return resource.getLocation().substring(location.getPath().length() + 1); } CqlMigrationResolver(ClassLoader classLoader, ScriptsLocation location, String encoding); List<ResolvedMigration> resolveMigrations(); }### Answer: @Test public void extractScriptName() { CqlMigrationResolver cqlMigrationResolver = new CqlMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocation("db/migration"), "UTF-8"); assertEquals( "db_0__init.cql", cqlMigrationResolver.extractScriptName( new ClassPathResource( "db/migration/db_0__init.cql", Thread.currentThread().getContextClassLoader()))); } @Test public void extractScriptNameRootLocation() { CqlMigrationResolver cqlMigrationResolver = new CqlMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocation(""), "UTF-8"); assertEquals( "db_0__init.cql", cqlMigrationResolver.extractScriptName( new ClassPathResource( "db_0__init.cql", Thread.currentThread().getContextClassLoader()))); } @Test public void extractScriptNameFileSystemPrefix() { CqlMigrationResolver cqlMigrationResolver = new CqlMigrationResolver( Thread.currentThread().getContextClassLoader(), new ScriptsLocation("filesystem:/some/dir"), "UTF-8"); assertEquals( "V3.171__patch.cql", cqlMigrationResolver.extractScriptName( new FileSystemResource("/some/dir/V3.171__patch.cql"))); }
### Question: Email { public boolean sendMail(List<String> emailList, String subject, String body) { return sendMail(emailList, subject, body, null); } 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(); }### Answer: @Test public void sendEmailToMultipleUser() throws MessagingException { List<String> to = new ArrayList<String>(); to.add("[email protected]"); to.add("[email protected]"); emailService.sendMail(to, subject, "Test email body"); List<Message> inbox = Mailbox.get("[email protected]"); Assert.assertTrue(inbox.size() > 0); Assert.assertEquals(subject, inbox.get(0).getSubject()); } @Test public void sendEmailWithCCTest() throws MessagingException { List<String> emailList = new ArrayList<String>(); emailList.add("[email protected]"); emailList.add("[email protected]"); List<String> ccEmailList = new ArrayList<String>(); ccEmailList.add("[email protected]"); ccEmailList.add("[email protected]"); emailService.sendMail(emailList, subject, "Email body to do email test", ccEmailList); List<Message> inbox = Mailbox.get("[email protected]"); Assert.assertTrue(inbox.size() > 0); Assert.assertEquals(subject, inbox.get(0).getSubject()); }
### Question: MigrationVersion implements Comparable<MigrationVersion> { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null \|\| getClass() != o.getClass()) return false; MigrationVersion version1 = (MigrationVersion) o; return compareTo(version1) == 0; } MigrationVersion(BigInteger version, String displayText); private MigrationVersion(String version); static MigrationVersion fromVersion(String version); String getVersion(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(MigrationVersion o); String getTable(); static final MigrationVersion EMPTY; static final MigrationVersion LATEST; static final MigrationVersion CURRENT; }### Answer: @Test public void testEquals() { final MigrationVersion a1 = MigrationVersion.fromVersion("1.2.3.3"); final MigrationVersion a2 = MigrationVersion.fromVersion("1.2.3.3"); assertTrue(a1.compareTo(a2) == 0); assertEquals(a1.hashCode(), a2.hashCode()); }
### Question: MigrationVersion implements Comparable<MigrationVersion> { public static MigrationVersion fromVersion(String version) { if ("current".equalsIgnoreCase(version)) return CURRENT; if (LATEST.getVersion().equals(version)) return LATEST; if (version == null) return EMPTY; return new MigrationVersion(version); } MigrationVersion(BigInteger version, String displayText); private MigrationVersion(String version); static MigrationVersion fromVersion(String version); String getVersion(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override int compareTo(MigrationVersion o); String getTable(); static final MigrationVersion EMPTY; static final MigrationVersion LATEST; static final MigrationVersion CURRENT; }### Answer: @Test(expected = CassandraMigrationException.class) public void missingNumber() { MigrationVersion.fromVersion("1..1"); } @Test(expected = CassandraMigrationException.class) public void dot() { MigrationVersion.fromVersion("."); } @Test(expected = CassandraMigrationException.class) public void startDot() { MigrationVersion.fromVersion(".1"); } @Test(expected = CassandraMigrationException.class) public void endDot() { MigrationVersion.fromVersion("1."); } @Test(expected = CassandraMigrationException.class) public void letters() { MigrationVersion.fromVersion("abc1.0"); } @Test(expected = CassandraMigrationException.class) public void dash() { MigrationVersion.fromVersion("1.2.1-3"); } @Test(expected = CassandraMigrationException.class) public void alphaNumeric() { MigrationVersion.fromVersion("1.2.1a-3"); }
### Question: Keyspace { public String getName() { return name; } Keyspace(); Cluster getCluster(); void setCluster(Cluster cluster); String getName(); void setName(String name); }### Answer: @Test public void shouldDefaultToNoKeyspaceButCanBeOverridden() { assertThat(new Keyspace().getName(), is(nullValue())); System.setProperty(Keyspace.KeyspaceProperty.NAME.getName(), "myspace"); assertThat(new Keyspace().getName(), is("myspace")); }
### Question: Keyspace { public Cluster getCluster() { return cluster; } Keyspace(); Cluster getCluster(); void setCluster(Cluster cluster); String getName(); void setName(String name); }### Answer: @Test public void shouldHaveDefaultClusterObject() { assertThat(new Keyspace().getCluster(), is(notNullValue())); }
### Question: StringUtils { public static String trimOrPad(String str, int length) { return trimOrPad(str, length, ' '); } private StringUtils(); static String trimOrPad(String str, int length); static String trimOrPad(String str, int length, char padChar); static boolean isNumeric(String str); static String collapseWhitespace(String str); static String left(String str, int count); static String replaceAll(String str, String originalToken, String replacementToken); static boolean hasLength(String str); static String arrayToCommaDelimitedString(Object[] strings); static boolean hasText(String s); static String[] tokenizeToStringArray(String str, String delimiters); static int countOccurrencesOf(String str, String token); static String replace(String inString, String oldPattern, String newPattern); static String collectionToCommaDelimitedString(Collection<?> collection); static String collectionToDelimitedString(Collection<?> collection, String delimiter); static String trimLeadingWhitespace(String str); static String trimTrailingWhitespace(String str); }### Answer: @Test public void trimOrPad() { assertEquals("Hello World ", StringUtils.trimOrPad("Hello World", 15)); assertEquals("Hello Worl", StringUtils.trimOrPad("Hello World", 10)); assertEquals(" ", StringUtils.trimOrPad(null, 10)); }
### Question: StringUtils { public static boolean isNumeric(String str) { return str != null && str.matches("\\d*"); } private StringUtils(); static String trimOrPad(String str, int length); static String trimOrPad(String str, int length, char padChar); static boolean isNumeric(String str); static String collapseWhitespace(String str); static String left(String str, int count); static String replaceAll(String str, String originalToken, String replacementToken); static boolean hasLength(String str); static String arrayToCommaDelimitedString(Object[] strings); static boolean hasText(String s); static String[] tokenizeToStringArray(String str, String delimiters); static int countOccurrencesOf(String str, String token); static String replace(String inString, String oldPattern, String newPattern); static String collectionToCommaDelimitedString(Collection<?> collection); static String collectionToDelimitedString(Collection<?> collection, String delimiter); static String trimLeadingWhitespace(String str); static String trimTrailingWhitespace(String str); }### Answer: @Test public void isNumeric() { assertFalse(StringUtils.isNumeric(null)); assertTrue(StringUtils.isNumeric("")); assertFalse(StringUtils.isNumeric(" ")); assertTrue(StringUtils.isNumeric("123")); assertFalse(StringUtils.isNumeric("12 3")); assertFalse(StringUtils.isNumeric("ab2c")); assertFalse(StringUtils.isNumeric("12-3")); assertFalse(StringUtils.isNumeric("12.3")); }
### Question: StringUtils { public static String collapseWhitespace(String str) { return str.replaceAll("\\s+", " "); } private StringUtils(); static String trimOrPad(String str, int length); static String trimOrPad(String str, int length, char padChar); static boolean isNumeric(String str); static String collapseWhitespace(String str); static String left(String str, int count); static String replaceAll(String str, String originalToken, String replacementToken); static boolean hasLength(String str); static String arrayToCommaDelimitedString(Object[] strings); static boolean hasText(String s); static String[] tokenizeToStringArray(String str, String delimiters); static int countOccurrencesOf(String str, String token); static String replace(String inString, String oldPattern, String newPattern); static String collectionToCommaDelimitedString(Collection<?> collection); static String collectionToDelimitedString(Collection<?> collection, String delimiter); static String trimLeadingWhitespace(String str); static String trimTrailingWhitespace(String str); }### Answer: @Test public void collapseWhitespace() { assertEquals("", StringUtils.collapseWhitespace("")); assertEquals("abc", StringUtils.collapseWhitespace("abc")); assertEquals("a b", StringUtils.collapseWhitespace("a b")); assertEquals(" a ", StringUtils.collapseWhitespace(" a ")); assertEquals(" a ", StringUtils.collapseWhitespace(" a ")); assertEquals("a b", StringUtils.collapseWhitespace("a b")); assertEquals("a b c", StringUtils.collapseWhitespace("a b c")); assertEquals(" a b c ", StringUtils.collapseWhitespace(" a b c ")); }
### Question: StringUtils { public static String[] tokenizeToStringArray(String str, String delimiters) { if (str == null) { return null; } String[] tokens = str.split("[" + delimiters + "]"); for (int i = 0; i < tokens.length; i++) { tokens[i] = tokens[i].trim(); } return tokens; } private StringUtils(); static String trimOrPad(String str, int length); static String trimOrPad(String str, int length, char padChar); static boolean isNumeric(String str); static String collapseWhitespace(String str); static String left(String str, int count); static String replaceAll(String str, String originalToken, String replacementToken); static boolean hasLength(String str); static String arrayToCommaDelimitedString(Object[] strings); static boolean hasText(String s); static String[] tokenizeToStringArray(String str, String delimiters); static int countOccurrencesOf(String str, String token); static String replace(String inString, String oldPattern, String newPattern); static String collectionToCommaDelimitedString(Collection<?> collection); static String collectionToDelimitedString(Collection<?> collection, String delimiter); static String trimLeadingWhitespace(String str); static String trimTrailingWhitespace(String str); }### Answer: @Test public void tokenizeToStringArray() { assertArrayEquals(new String[] {"abc"}, StringUtils.tokenizeToStringArray("abc", ",")); assertArrayEquals( new String[] {"abc", "def"}, StringUtils.tokenizeToStringArray("abc,def", ",")); assertArrayEquals( new String[] {"abc", "def"}, StringUtils.tokenizeToStringArray(" abc ,def ", ",")); assertArrayEquals(new String[] {"", "abc"}, StringUtils.tokenizeToStringArray(",abc", ",")); assertArrayEquals(new String[] {"", "abc"}, StringUtils.tokenizeToStringArray(" , abc", ",")); }
### Question: ClassUtils { public static boolean isPresent(String className, ClassLoader classLoader) { try { classLoader.loadClass(className); return true; } catch (Throwable ex) { return false; } } private ClassUtils(); @SuppressWarnings({"unchecked"}) // Must be synchronized for the Maven Parallel Junit runner to work static synchronized T instantiate(String className, ClassLoader classLoader); static List<T> instantiateAll(String[] classes, ClassLoader classLoader); static boolean isPresent(String className, ClassLoader classLoader); static String getShortName(Class<?> aClass); static String getLocationOnDisk(Class<?> aClass); }### Answer: @Test public void isPresent() { assertTrue( ClassUtils.isPresent( "com.contrastsecurity.cassandra.migration.CassandraMigration", Thread.currentThread().getContextClassLoader())); } @Test public void isPresentNot() { assertFalse( ClassUtils.isPresent( "com.example.FakeClass", Thread.currentThread().getContextClassLoader())); }
### Question: FeatureDetector { public boolean isSlf4jAvailable() { if (slf4jAvailable == null) { slf4jAvailable = isPresent("org.slf4j.Logger", classLoader); } return slf4jAvailable; } FeatureDetector(ClassLoader classLoader); boolean isApacheCommonsLoggingAvailable(); boolean isSlf4jAvailable(); }### Answer: @Test public void shouldDetectSlf4j() { assertThat( new FeatureDetector(Thread.currentThread().getContextClassLoader()).isSlf4jAvailable(), is(true)); }
### Question: FeatureDetector { public boolean isApacheCommonsLoggingAvailable() { if (apacheCommonsLoggingAvailable == null) { apacheCommonsLoggingAvailable = isPresent("org.apache.commons.logging.Log", classLoader); } return apacheCommonsLoggingAvailable; } FeatureDetector(ClassLoader classLoader); boolean isApacheCommonsLoggingAvailable(); boolean isSlf4jAvailable(); }### Answer: @Test public void shouldDetectCommonsLogging() { assertThat( new FeatureDetector(Thread.currentThread().getContextClassLoader()) .isApacheCommonsLoggingAvailable(), is(true)); }
### Question: TimeFormat { public static String format(long millis) { return String.format( "%02d:%02d.%03ds", millis / 60000, (millis % 60000) / 1000, (millis % 1000)); } private TimeFormat(); static String format(long millis); }### Answer: @Test public void format() { assertEquals("00:00.001s", TimeFormat.format(1)); assertEquals("00:00.012s", TimeFormat.format(12)); assertEquals("00:00.123s", TimeFormat.format(123)); assertEquals("00:01.234s", TimeFormat.format(1234)); assertEquals("00:12.345s", TimeFormat.format(12345)); assertEquals("01:23.456s", TimeFormat.format(60000 + 23456)); assertEquals("12:34.567s", TimeFormat.format((60000 * 12) + 34567)); assertEquals("123:45.678s", TimeFormat.format((60000 * 123) + 45678)); }
### Question: Email { public void sendAttachment( List<String> emailList, String emailBody, String subject, String filePath) { try { Session session = getSession(); MimeMessage message = new MimeMessage(session); addRecipient(message, Message.RecipientType.TO, emailList); message.setSubject(subject); Multipart multipart = createMultipartData(emailBody, filePath); setMessageAttribute(message, fromEmail, subject, multipart); sendEmail(session, message); } catch (Exception e) { logger.error("Exception occured during email sending " + e, e); } } 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(); }### Answer: @Test public void sendEmailWithAttachmentTest() throws MessagingException { List<String> to = new ArrayList<String>(); to.add("[email protected]"); to.add("[email protected]"); emailService.sendAttachment(to, "Test email as attached.", subject, "emailtemplate.vm"); List<Message> inbox = Mailbox.get("[email protected]"); Assert.assertTrue(inbox.size() > 0); Assert.assertEquals(subject, inbox.get(0).getSubject()); }
### Question: FileSystemResource implements Resource, Comparable<FileSystemResource> { public String getFilename() { return location.getName(); } FileSystemResource(String location); String getLocation(); String getLocationOnDisk(); String loadAsString(String encoding); byte[] loadAsBytes(); String getFilename(); @SuppressWarnings("NullableProblems") int compareTo(FileSystemResource o); }### Answer: @Test public void getFilename() throws Exception { assertEquals("Mig777__Test.cql", new FileSystemResource("Mig777__Test.cql").getFilename()); assertEquals( "Mig777__Test.cql", new FileSystemResource("folder/Mig777__Test.cql").getFilename()); }
### Question: FileSystemResource implements Resource, Comparable<FileSystemResource> { public String getLocation() { return StringUtils.replaceAll(location.getPath(), "\\", "/"); } FileSystemResource(String location); String getLocation(); String getLocationOnDisk(); String loadAsString(String encoding); byte[] loadAsBytes(); String getFilename(); @SuppressWarnings("NullableProblems") int compareTo(FileSystemResource o); }### Answer: @Test public void getPath() throws Exception { assertEquals("Mig777__Test.cql", new FileSystemResource("Mig777__Test.cql").getLocation()); assertEquals( "folder/Mig777__Test.cql", new FileSystemResource("folder/Mig777__Test.cql").getLocation()); }
### Question: ClassPathResource implements Comparable<ClassPathResource>, Resource { public String getFilename() { return location.substring(location.lastIndexOf("/") + 1); } ClassPathResource(String location, ClassLoader classLoader); String getLocation(); String getLocationOnDisk(); String loadAsString(String encoding); byte[] loadAsBytes(); String getFilename(); boolean exists(); @SuppressWarnings({"RedundantIfStatement"}) @Override boolean equals(Object o); @Override int hashCode(); @SuppressWarnings("NullableProblems") int compareTo(ClassPathResource o); }### Answer: @Test public void getFilename() throws Exception { assertEquals( "Mig777__Test.cql", new ClassPathResource("Mig777__Test.cql", Thread.currentThread().getContextClassLoader()) .getFilename()); assertEquals( "Mig777__Test.cql", new ClassPathResource( "folder/Mig777__Test.cql", Thread.currentThread().getContextClassLoader()) .getFilename()); }
### Question: ClassPathResource implements Comparable<ClassPathResource>, Resource { public String loadAsString(String encoding) { try { InputStream inputStream = classLoader.getResourceAsStream(location); if (inputStream == null) { throw new CassandraMigrationException( "Unable to obtain inputstream for resource: " + location); } Reader reader = new InputStreamReader(inputStream, Charset.forName(encoding)); return FileCopyUtils.copyToString(reader); } catch (IOException e) { throw new CassandraMigrationException( "Unable to load resource: " + location + " (encoding: " + encoding + ")", e); } } ClassPathResource(String location, ClassLoader classLoader); String getLocation(); String getLocationOnDisk(); String loadAsString(String encoding); byte[] loadAsBytes(); String getFilename(); boolean exists(); @SuppressWarnings({"RedundantIfStatement"}) @Override boolean equals(Object o); @Override int hashCode(); @SuppressWarnings("NullableProblems") int compareTo(ClassPathResource o); }### Answer: @Test public void loadAsStringUtf8WithoutBOM() { assertEquals( "SELECT * FROM contents;", new ClassPathResource( "com/contrastsecurity/cassandra/migration/utils/scanner/classpath/utf8.nofilter", Thread.currentThread().getContextClassLoader()) .loadAsString("UTF-8")); } @Test public void loadAsStringUtf8WithBOM() { assertEquals( "SELECT * FROM contents;", new ClassPathResource( "com/contrastsecurity/cassandra/migration/utils/scanner/classpath/utf8bom.nofilter", Thread.currentThread().getContextClassLoader()) .loadAsString("UTF-8")); }
### Question: UrlUtils { public static String toFilePath(URL url) { try { String filePath = new File(URLDecoder.decode(url.getPath().replace("+", "%2b"), "UTF-8")).getAbsolutePath(); if (filePath.endsWith("/")) { return filePath.substring(0, filePath.length() - 1); } return filePath; } catch (UnsupportedEncodingException e) { throw new IllegalStateException("Can never happen", e); } } private UrlUtils(); static String toFilePath(URL url); }### Answer: @Test public void toFilePath() throws MalformedURLException { File file = new File("/test dir/a+b"); assertEquals(file.getAbsolutePath(), UrlUtils.toFilePath(file.toURI().toURL())); }
### Question: EsClientFactory { private static ElasticSearchService getTcpClient() { if (tcpClient == null) { tcpClient = new ElasticSearchTcpImpl(); } return tcpClient; } static ElasticSearchService getInstance(String type); }### Answer: @Test public void testGetTcpClient() { ElasticSearchService service = EsClientFactory.getInstance("tcp"); Assert.assertTrue(service instanceof ElasticSearchTcpImpl); }
### Question: EsClientFactory { private static ElasticSearchService getRestClient() { if (restClient == null) { restClient = new ElasticSearchRestHighImpl(); } return restClient; } static ElasticSearchService getInstance(String type); }### Answer: @Test public void testGetRestClient() { ElasticSearchService service = EsClientFactory.getInstance("rest"); Assert.assertTrue(service instanceof ElasticSearchRestHighImpl); }
### Question: EsClientFactory { public static ElasticSearchService getInstance(String type) { if (JsonKey.TCP.equals(type)) { return getTcpClient(); } else 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); }### Answer: @Test public void testInstanceNull() { ElasticSearchService service = EsClientFactory.getInstance("test"); Assert.assertNull(service); }
### Question: SmtpEMailServiceImpl implements IEmailService { @Override public boolean sendEmail(EmailRequest emailReq) { if (emailReq == null) { logger.info("Email request is null or empty:"); return false; } else if (CollectionUtils.isNotEmpty(emailReq.getBcc()) \|\| emailReq.getTo().size() > 1) { return email.sendEmail( email.getFromEmail(), emailReq.getSubject(), emailReq.getBody(), CollectionUtils.isEmpty(emailReq.getBcc()) ? emailReq.getTo() : emailReq.getBcc()); } else if (CollectionUtils.isNotEmpty(emailReq.getCc())) { return email.sendMail( emailReq.getTo(), emailReq.getSubject(), emailReq.getBody(), emailReq.getCc()); } else { return email.sendMail(emailReq.getTo(), emailReq.getSubject(), emailReq.getBody()); } } SmtpEMailServiceImpl(); SmtpEMailServiceImpl(EmailConfig config); @Override boolean sendEmail(EmailRequest emailReq); }### Answer: @Test public void sendEmailFailure () { List<String> to = new ArrayList<String>(); Map<String,String> param = new HashMap<String, String>(); param.put("name", "test"); EmailRequest emailReq = new EmailRequest("testEmail", to, null, null, "emailtemplate", null, param); boolean response = service.sendEmail(emailReq); assertFalse(response); }
### Question: RDAPCLI { public static Type guessQueryType(String query) { try { if (query.matches("^\\d+$")) { return Type.AUTNUM; } if (query.matches("^[\\d\\.:/]+$")) { return Type.IP; } if (DomainName.of(query).getLevelSize() > 1) { return Type.DOMAIN; } return Type.ENTITY; } catch (IllegalArgumentException iae) { LOGGER.debug("Not a domain name, defaulting to entity", iae); return Type.ENTITY; } } private RDAPCLI(); static void main(String[] args); static Type guessQueryType(String query); }### Answer: @Test public void testGuess() { assertEquals(RDAPCLI.Type.AUTNUM,RDAPCLI.guessQueryType("12345")); assertEquals(RDAPCLI.Type.IP,RDAPCLI.guessQueryType("127.0.0.0/8")); assertEquals(RDAPCLI.Type.DOMAIN, RDAPCLI.guessQueryType("foo.example")); assertEquals(RDAPCLI.Type.ENTITY,RDAPCLI.guessQueryType("handle")); }
### Question: DomainName { public boolean isFQDN() { return labels.get(labels.size() - 1) instanceof Label.RootLabel; } DomainName(List<Label> labels); static DomainName of(String domainName); DomainName toFQDN(); boolean isFQDN(); int getLevelSize(); List<Label> getLabels(); Label getTLDLabel(); String getStringValue(); Label getLevel(int level); DomainName toLDH(); DomainName toUnicode(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testIsFQDN() { assertFalse(DomainName.of("www.example.com").isFQDN()); assertTrue(DomainName.of("www.example.com.").isFQDN()); }
### Question: DomainName { public DomainName toFQDN() { if (isFQDN()) { return this; } return new DomainName(new ImmutableList.Builder<Label>().addAll(labels).add(Label.RootLabel.getInstance()).build()); } DomainName(List<Label> labels); static DomainName of(String domainName); DomainName toFQDN(); boolean isFQDN(); int getLevelSize(); List<Label> getLabels(); Label getTLDLabel(); String getStringValue(); Label getLevel(int level); DomainName toLDH(); DomainName toUnicode(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testToFQDN() { DomainName dn = DomainName.of("www.example.com"); assertEquals(4, dn.toFQDN().getLabels().size()); assertEquals("www.example.com.", dn.toFQDN().getStringValue()); }
### Question: Tel extends URIValue { public static Tel unvalidatedTel(String telephoneNumber) throws URISyntaxException { return new Tel(new URI("tel:" + telephoneNumber)); } private Tel(URI uri); Tel(TelephoneNumber telephoneNumber); Tel(String telephoneNumber); static Tel unvalidatedTel(String telephoneNumber); }### Answer: @Test public void shouldBePossibleToCreateUnvalidedPhoneNumber() throws URISyntaxException { Tel tel = Tel.unvalidatedTel("+29716"); assertNotNull(tel); assertEquals("tel:+29716", tel.getStringValue()); }
### Question: Label { public Label toUnicode() { return this; } Label(String value); static Label of(final String label); String getStringValue(); Label toLDH(); Label toUnicode(); static final Logger LOGGER; static final int IDNA_OPTIONS; }### Answer: @Test public void testToUnicode() { Label label = Label.of("xn--bcher-kva"); assertEquals("b\u00FCcher", label.toUnicode().getStringValue()); }
### Question: Label { public Label toLDH() { return this; } Label(String value); static Label of(final String label); String getStringValue(); Label toLDH(); Label toUnicode(); static final Logger LOGGER; static final int IDNA_OPTIONS; }### Answer: @Test public void testToLDH() { Label label = Label.of("b\u00FCcher"); assertEquals("xn--bcher-kva", label.toLDH().getStringValue()); label = Label.of("Bu\u0308cher"); assertEquals("xn--bcher-kva", label.toLDH().getStringValue()); assertEquals("b\u00FCcher", label.getStringValue()); }
### Question: CIDR { public static CIDR of(String cidr) { String[] parts = cidr.split("\\/"); if (parts.length == 1) { try { InetAddress address = InetAddress.getByName(parts[0]); int length = address instanceof Inet4Address ? 32 : 128; return new CIDR(address.getAddress(), length); } catch (UnknownHostException e) { throw new IllegalArgumentException(e); } } if (parts.length != 2) { throw new IllegalArgumentException("Invalid format"); } try { InetAddress address = InetAddress.getByName(parts[0]); return new CIDR(address.getAddress(),Integer.parseInt(parts[1])); } catch (UnknownHostException e) { throw new IllegalArgumentException(e); } } CIDR(byte[] address, int size); byte[] getAddress(); int getSize(); byte[] getMask(); boolean contains(InetAddress inet); static CIDR of(String cidr); }### Answer: @Test public void testDoesItSmoke() { Assert.assertThrows(new Assert.Closure() { @Override public void execute() throws Throwable { CIDR.of("1.1.1.1/-1"); } }, IllegalArgumentException.class, "negative prefix size"); }
### Question: AlphanumStringComparator implements Comparator<String> { @Override public int compare(String s1, String s2) { int c = 0; Matcher m1 = prefixRexp.matcher(s1); Matcher m2 = prefixRexp.matcher(s2); if (m1.find() && m2.find()) { Integer i1 = Integer.valueOf(m1.group(1)); Integer i2 = Integer.valueOf(m2.group(1)); c = i1.compareTo(i2); } else { throw new IllegalArgumentException("Can not compare strings missing 'digit@' pattern"); } return c; } @Override int compare(String s1, String s2); }### Answer: @Test public void should_correctly_compare_alphanumerical_strings() throws Exception { AlphanumStringComparator comparator = new AlphanumStringComparator(); assertTrue(comparator.compare("10@foo", "2@foo") > 0); assertTrue(comparator.compare("2@foo", "10@foo") < 0); assertTrue(comparator.compare("10@foo", "10@foo") == 0); }
### Question: SimpleDbRepositoryQuery implements RepositoryQuery { void assertNotHavingNestedQueryParameters(String query) { List<String> attributesFromQuery = QueryUtils.getQueryPartialFieldNames(query); final Class<?> domainClass = method.getDomainClazz(); for(String attribute : attributesFromQuery) { try { Field field = ReflectionUtils.getDeclaredFieldInHierarchy(domainClass, attribute); if(FieldTypeIdentifier.isOfType(field, FieldType.NESTED_ENTITY)) { throw new IllegalArgumentException("Invalid query parameter :" + attribute + " is nested object"); } } catch(NoSuchFieldException e) { } } } SimpleDbRepositoryQuery(SimpleDbQueryMethod method, SimpleDbOperations simpledbOperations); @Override Object execute(Object[] parameters); @Override QueryMethod getQueryMethod(); static RepositoryQuery fromQueryAnnotation(SimpleDbQueryMethod queryMethod, SimpleDbOperations simpleDbOperations); }### Answer: @SuppressWarnings({ "rawtypes", "unchecked" }) @Test(expected = IllegalArgumentException.class) public void assertNotHavingNestedQueryParameters_should_fail_for_nested_attributes() { SimpleDbQueryMethod method = Mockito.mock(SimpleDbQueryMethod.class); Mockito.when(method.getDomainClazz()).thenReturn((Class) SampleEntity.class); SimpleDbRepositoryQuery repositoryQuery = new SimpleDbRepositoryQuery(method, null); repositoryQuery.assertNotHavingNestedQueryParameters("select sampleNestedAttribute from SampleEntity"); }
### Question: SimpleDbQueryRunner { public Object executeSingleResultQuery() { List<?> returnListFromDb = executeQuery(); return getSingleResult(returnListFromDb); } SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query); SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query, Pageable pageable); List<?> executeQuery(); Object executeSingleResultQuery(); long executeCount(); List<String> getRequestedQueryFieldNames(); String getSingleQueryFieldName(); Page<?> executePagedQuery(); }### Answer: @Test(expected = IllegalArgumentException.class) public void executeSingleResultQuery_should_fail_if_multiple_results_are_retrieved() { SimpleDbOperations simpleDbOperations = Mockito.mock(SimpleDbOperations.class); List<SampleEntity> sampleMultipleResults = new ArrayList<SampleEntity>(); sampleMultipleResults.add(new SampleEntity()); sampleMultipleResults.add(new SampleEntity()); Mockito.when(simpleDbOperations.find(Mockito.same(SampleEntity.class), Mockito.anyString())).thenReturn( sampleMultipleResults); SimpleDbQueryRunner runner = new SimpleDbQueryRunner((SimpleDbOperations) simpleDbOperations, SampleEntity.class, null); runner.executeSingleResultQuery(); }
### Question: SimpleDbQueryRunner { Object getSingleResult(List<?> returnListFromDb) { Assert.isTrue(returnListFromDb.size() <= 1, "Select statement should return only one entity from database, returned elements size=" + returnListFromDb.size() + ", for Query=" + query); return returnListFromDb.size() > 0 ? returnListFromDb.get(0) : null; } SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query); SimpleDbQueryRunner(SimpleDbOperations simpledbOperations, Class<?> domainClass, String query, Pageable pageable); List<?> executeQuery(); Object executeSingleResultQuery(); long executeCount(); List<String> getRequestedQueryFieldNames(); String getSingleQueryFieldName(); Page<?> executePagedQuery(); }### Answer: @Test public void getSingleResult_should_return_null_for_empty_list() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final Object result = runner.getSingleResult(new ArrayList<SampleEntity>()); assertNull(result); } @Test public void getSingleResult_should_return_single_value_from_list_with_one_element() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final ArrayList<SampleEntity> results = new ArrayList<SampleEntity>(); results.add(new SampleEntity()); final Object result = runner.getSingleResult(results); assertNotNull(result); } @Test(expected = IllegalArgumentException.class) public void getSingleResult_should_fail_for_list_with_multiple_elements() { SimpleDbQueryRunner runner = new SimpleDbQueryRunner(null, SampleEntity.class, null); final ArrayList<SampleEntity> results = new ArrayList<SampleEntity>(); results.add(new SampleEntity()); results.add(new SampleEntity()); runner.getSingleResult(results); }
### Question: SimpleDbResultConverter { public static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName) { List<Object> ret = new ArrayList<Object>(); for(Object object : domainObjects) { ret.add(ReflectionUtils.callGetter(object, attributeName)); } return ret; } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void filterNamedAttributesAsList_should_return_list_of_named_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entities.add(entity); List<Object> filteredAttributes = SimpleDbResultConverter.filterNamedAttributesAsList(entities, "sampleAttribute"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.get(0); assertEquals(SAMPLE_INT_VALUE, firstElement); } @Test public void filterNamedAttributesAsList_should_work_for_list_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleList(new ArrayList<Integer>()); entities.add(entity); List<Object> filteredAttributes = SimpleDbResultConverter.filterNamedAttributesAsList(entities, "sampleList"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.get(0); assertTrue(firstElement instanceof List); } @Test(expected = MappingException.class) public void filterNamedAttributesAsList_should_not_return_list_of_named_attributes_for_wrong_att() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entities.add(entity); SimpleDbResultConverter.filterNamedAttributesAsList(entities, "wrongAttribute"); }
### Question: SimpleDbResultConverter { public static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName) { Set<Object> ret = new LinkedHashSet<Object>(); for(Object object : domainObjects) { ret.add(ReflectionUtils.callGetter(object, attributeName)); } return ret; } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void filterNamedAttributesAsSet_should_return_Set_of_named_attributes() throws Exception { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entities.add(entity); Set<Object> filteredAttributes = SimpleDbResultConverter .filterNamedAttributesAsSet(entities, "sampleAttribute"); assertEquals(1, filteredAttributes.size()); Object firstElement = filteredAttributes.iterator().next(); assertEquals(SAMPLE_INT_VALUE, firstElement); }
### Question: SimpleDbResultConverter { public static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames) { if(entityList.size() > 0) { List<List<Object>> rows = new ArrayList<List<Object>>(); for(Object entity : entityList) { List<Object> cols = new ArrayList<Object>(); for(String fieldName : requestedQueryFieldNames) { Object value = ReflectionUtils.callGetter(entity, fieldName); cols.add(value); } rows.add(cols); } return rows; } else { return Collections.emptyList(); } } private SimpleDbResultConverter(); static List<Object> filterNamedAttributesAsList(List<?> domainObjects, String attributeName); static Set<Object> filterNamedAttributesAsSet(List<?> domainObjects, String attributeName); static List<List<Object>> toListOfListOfObject(List<?> entityList, List<String> requestedQueryFieldNames); }### Answer: @Test public void toListOfListOfObject_should_return_List_of_Lists_containing_requested_attributes() { List<SampleEntity> entities = new ArrayList<SampleEntity>(); SampleEntity entity = new SampleEntity(); entity.setSampleAttribute(SAMPLE_INT_VALUE); entity.setSampleList(new ArrayList<Integer>()); entities.add(entity); List<String> attributes = Arrays.asList("sampleAttribute", "sampleList"); List<List<Object>> filteredAttributes = SimpleDbResultConverter.toListOfListOfObject(entities, attributes); assertEquals(1, filteredAttributes.size()); List<Object> columns = filteredAttributes.get(0); assertEquals(2, columns.size()); assertEquals(SAMPLE_INT_VALUE, columns.get(0)); }
### Question: PagedResultExecution extends AbstractSimpleDbQueryExecution { @Override protected Object doExecute(SimpleDbQueryMethod queryMethod, SimpleDbQueryRunner queryRunner) { final Page<?> pagedResult = queryRunner.executePagedQuery(); if(queryMethod.isPageQuery()) { return pagedResult; } return pagedResult.getContent(); } PagedResultExecution(SimpleDbOperations simpleDbOperations); }### Answer: @Test @SuppressWarnings({ "rawtypes", "unchecked" }) public void doExecute_should_return_Page_type() throws Exception { final SimpleDbQueryMethod repositoryMethod = prepareQueryMethodToTest("selectAllIntoPage", SampleEntity.class); final PagedResultExecution execution = new PagedResultExecution(null); final SimpleDbQueryRunner queryRunner = Mockito.mock(SimpleDbQueryRunner.class); when(queryRunner.executePagedQuery()).thenReturn(new PageImpl(new ArrayList())); final Object result = execution.doExecute(repositoryMethod, queryRunner); assertTrue(Page.class.isAssignableFrom(result.getClass())); } @Test @SuppressWarnings({ "rawtypes", "unchecked" }) public void doExecute_should_return_List_type() throws Exception { final SimpleDbQueryMethod repositoryMethod = prepareQueryMethodToTest("selectAllIntoList", SampleEntity.class); final PagedResultExecution execution = new PagedResultExecution(null); final SimpleDbQueryRunner queryRunner = Mockito.mock(SimpleDbQueryRunner.class); when(queryRunner.executePagedQuery()).thenReturn(new PageImpl(new ArrayList())); final Object result = execution.doExecute(repositoryMethod, queryRunner); assertTrue(List.class.isAssignableFrom(result.getClass())); }
### Question: SimpleDBAttributeConverter { public static Object decodeToPrimitiveArray(List<String> fromSimpleDbAttValues, Class<?> retType) throws ParseException { Object primitiveCollection = Array.newInstance(retType, fromSimpleDbAttValues.size()); int idx = 0; for(Iterator<String> iterator = fromSimpleDbAttValues.iterator(); iterator.hasNext(); idx++) { Array.set(primitiveCollection, idx, decodeToFieldOfType(iterator.next(), retType)); } return primitiveCollection; } private SimpleDBAttributeConverter(); static String encode(Object ob); static List<String> encodeArray(final Object arrayValues); static Object decodeToFieldOfType(String value, Class<?> retType); static Object decodeToPrimitiveArray(List<String> fromSimpleDbAttValues, Class<?> retType); }### Answer: @Test public void toSimpleDBAttributeValues_should_return_an_string_representation_of_concatenated_array_elements() throws ParseException { final int[] expectedIntArray = { 1, 2, 3, 4 }; final List<String> simpleDBValues = Arrays.asList("1", "2", "3", "4"); Object returnedPrimitiveCol = SimpleDBAttributeConverter.decodeToPrimitiveArray(simpleDBValues, int.class); int arrayLength = Array.getLength(returnedPrimitiveCol); for(int idx = 0; idx < arrayLength; idx++) { assertEquals(expectedIntArray[idx], Array.get(returnedPrimitiveCol, idx)); } }
### Question: QueryBuilder { @Override public String toString() { String result = query.toString(); LOGGER.debug("Created query: {}", result); return result; } QueryBuilder(SimpleDbEntityInformation<?, ?> entityInformation); QueryBuilder(SimpleDbEntityInformation<?, ?> entityInformation, boolean shouldCount); QueryBuilder(String customQuery); QueryBuilder(String customQuery, boolean shouldCount); QueryBuilder withLimit(final int limit); QueryBuilder withIds(Iterable<?> iterable); QueryBuilder with(Sort sort); QueryBuilder with(Pageable pageable); @Override String toString(); }### Answer: @Test public void should_create_correct_queries_if_no_other_clauses_are_specified() throws Exception { QueryBuilder builder = new QueryBuilder(SimpleDbSampleEntity.entityInformation()); String returnedQuery = builder.toString(); assertEquals("select * from `simpleDbSampleEntity`", returnedQuery); } @Test public void should_include_count_clause_if_requested() throws Exception { QueryBuilder builder = new QueryBuilder(SimpleDbSampleEntity.entityInformation(), true); String returnedQuery = builder.toString(); assertThat(returnedQuery, containsString("select count(*) from")); }
### Question: DomainItemBuilder { public T populateDomainItem(SimpleDbEntityInformation<T, ?> entityInformation, Item item) { return buildDomainItem(entityInformation, item); } List<T> populateDomainItems(SimpleDbEntityInformation<T, ?> entityInformation, SelectResult selectResult); T populateDomainItem(SimpleDbEntityInformation<T, ?> entityInformation, Item item); }### Answer: @Test public void populateDomainItem_should_convert_item_name() { Item sampleItem = new Item(SAMPLE_ITEM_NAME, new ArrayList<Attribute>()); SimpleDbEntityInformation<SimpleDbSampleEntity, String> entityInformation = SimpleDbSampleEntity .entityInformation(); domainItemBuilder = new DomainItemBuilder<SimpleDbSampleEntity>(); SimpleDbSampleEntity returnedDomainEntity = domainItemBuilder.populateDomainItem(entityInformation, sampleItem); assertEquals(SAMPLE_ITEM_NAME, returnedDomainEntity.getItemName()); } @Test public void populateDomainItem_should_convert_attributes() { List<Attribute> attributeList = new ArrayList<Attribute>(); attributeList.add(new Attribute("booleanField", "" + SAMPLE_BOOLEAN_ATT_VALUE)); Item sampleItem = new Item(SAMPLE_ITEM_NAME, attributeList); SimpleDbEntityInformation<SimpleDbSampleEntity, String> entityInformation = SimpleDbSampleEntity .entityInformation(); domainItemBuilder = new DomainItemBuilder<SimpleDbSampleEntity>(); SimpleDbSampleEntity returnedDomainEntity = domainItemBuilder.populateDomainItem(entityInformation, sampleItem); assertTrue(returnedDomainEntity.getBooleanField() == SAMPLE_BOOLEAN_ATT_VALUE); }
### Question: Util { public static <T> T stringMapToValidObject(Class<T> clazz, Map<String, String> data) { T object = stringMapToObject(clazz, data); Set<ConstraintViolation<T>> validate = validator.validate(object); if (validate.isEmpty()) { return object; } else { throw new IllegalArgumentException("Created object was not valid"); } } private Util(); static String getDefaultMusicFolder(); static String getDefaultPodcastFolder(); static String getDefaultPlaylistFolder(); static boolean isWindows(); static void setContentLength(HttpServletResponse response, long length); static List<T> subList(List<T> list, long offset, long max); static List<Integer> toIntegerList(int[] values); static int[] toIntArray(List<Integer> values); static String debugObject(Object object); static String getURLForRequest(HttpServletRequest request); static String getAnonymizedURLForRequest(HttpServletRequest request); static boolean isInstanceOfClassName(Object o, String className); static Map<String, String> objectToStringMap(Object object); static T stringMapToObject(Class<T> clazz, Map<String, String> data); static T stringMapToValidObject(Class<T> clazz, Map<String, String> data); }### Answer: @Test(expected = IllegalArgumentException.class) public void stringMapToValidObjectWithNoData() { Map<String, String> stringStringMap = new HashMap<>(); MediaLibraryStatistics statistics = Util.stringMapToValidObject(MediaLibraryStatistics.class, stringStringMap); }
### Question: JWTSecurityService { public String addJWTToken(String uri) { return addJWTToken(UriComponentsBuilder.fromUriString(uri)).build().toString(); } @Autowired JWTSecurityService(SettingsService settingsService); static String generateKey(); static Algorithm getAlgorithm(String jwtKey); String addJWTToken(String uri); UriComponentsBuilder addJWTToken(UriComponentsBuilder builder); UriComponentsBuilder addJWTToken(UriComponentsBuilder builder, Date expires); static DecodedJWT verify(String jwtKey, String token); DecodedJWT verify(String credentials); static final String JWT_PARAM_NAME; static final String CLAIM_PATH; static final int DEFAULT_DAYS_VALID_FOR; }### Answer: @Test public void addJWTToken() { UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(uriString); String actualUri = service.addJWTToken(builder).build().toUriString(); String jwtToken = UriComponentsBuilder.fromUriString(actualUri).build().getQueryParams().getFirst( JWTSecurityService.JWT_PARAM_NAME); DecodedJWT verify = verifier.verify(jwtToken); Claim claim = verify.getClaim(JWTSecurityService.CLAIM_PATH); assertEquals(expectedClaimString, claim.asString()); }
### Question: ReadmeBuilder { @Override public String toString() { Parser markdownParser = Parser.builder().build(); Node markdownDocument = markdownParser.parse(this.markdownText); HtmlRenderer renderer = HtmlRenderer.builder().build(); return TEMPLATE.replace(README_TEMPLATE_TITLE_KEY, this.pageTitle) .replace(README_TEMPLATE_BODY_KEY, renderer.render(markdownDocument)); } ReadmeBuilder(String markdownText, String pageTitle); static ReadmeBuilder fromMarkdownResource(String title, String path, TransformationContext context); @Override String toString(); }### Answer: @Test public void testBuilderWithMarkdownString() { logger.info("Initilaizing Readme Builder"); ReadmeBuilder builder = new ReadmeBuilder("# Hello World", "Hello"); logger.info("Rendering"); String result = builder.toString(); logger.info("Rendered: {}", result); assertTrue(result.contains("<h1>Hello World</h1>")); assertTrue(result.contains("<title>Hello</title>")); }
### Question: KubernetesPlugin extends ToscanaPlugin<KubernetesLifecycle> { @Override public KubernetesLifecycle getInstance(TransformationContext context) throws Exception { return new KubernetesLifecycle(context, mapper); } @Autowired KubernetesPlugin(BaseImageMapper mapper); @Override KubernetesLifecycle getInstance(TransformationContext context); static final String DOCKER_PUSH_TO_REGISTRY_PROPERTY_KEY; static final String DOCKER_REGISTRY_URL_PROPERTY_KEY; static final String DOCKER_REGISTRY_USERNAME_PROPERTY_KEY; static final String DOCKER_REGISTRY_PASSWORD_PROPERTY_KEY; static final String DOCKER_REGISTRY_REPOSITORY_PROPERTY_KEY; }### Answer: @Test(expected = ValidationFailureException.class) public void modelCheckTest() throws Exception { EffectiveModel singleComputeModel = new EffectiveModelFactory().create(TestCsars.VALID_SINGLE_COMPUTE_WINDOWS_TEMPLATE, logMock()); TransformationContext context = setUpMockTransformationContext(singleComputeModel); KubernetesLifecycle lifecycle = plugin.getInstance(context); plugin.transform(lifecycle); }
### Question: SudoUtils { public static Optional<String> getSudoInstallCommand(String baseImage) { String imageName = baseImage.split(":")[0]; return Optional.ofNullable(IMAGE_MAP.get(imageName)); } static Optional<String> getSudoInstallCommand(String baseImage); }### Answer: @Test public void validate() { Optional<String> result = SudoUtils.getSudoInstallCommand(input); if (expected == null) { assertTrue(!result.isPresent()); return; } String r = result.get(); assertEquals(r, expected); }
### Question: ResourceFileCreator { public HashMap<String, String> getResourceYaml() throws JsonProcessingException { HashMap<String, String> result = new HashMap<>(); for (IKubernetesResource<?> resource : resources) { result.put(resource.getName(), resource.toYaml()); } return result; } ResourceFileCreator(Collection<Pod> pods); HashMap<String, String> getResourceYaml(); }### Answer: @Test public void testReplicationControllerCreation() { ResourceFileCreator resourceFileCreator = new ResourceFileCreator(Pod.getPods(TestNodeStacks.getLampNodeStacks(logMock()))); HashMap<String, String> result = null; try { result = resourceFileCreator.getResourceYaml(); } catch (JsonProcessingException e) { e.printStackTrace(); fail(); } String service = result.get(appServiceName); String deployment = result.get(appDeploymentName); Yaml yaml = new Yaml(); deploymentTest((Map) yaml.load(deployment)); }
### Question: MapperUtils { public static boolean anythingSet(OsCapability capability) { Optional[] optionals = { capability.getDistribution(), capability.getArchitecture(), capability.getType(), capability.getVersion() }; return Arrays.stream(optionals).anyMatch(Optional::isPresent); } static boolean anythingSet(OsCapability capability); static final Comparator<DockerImageTag> TAG_COMPARATOR_MINOR_VERSION; }### Answer: @Test public void testNoneSet() { assertFalse(anythingSet(new OsCapability(entity))); } @Test public void testOneSet() { assertTrue(anythingSet(new OsCapability(entity).setType(Type.LINUX))); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.