method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
BusinessServDetailService { public BusinessServiceDetailResponse searchBusinessServiceDetails( final BusinessServiceDetailCriteria businessServiceDetailCriteria, final RequestInfo requestInfo) { final List<BusinessServiceDetail> businessServiceDetails = businessServiceDetailRepository .getBussinessServiceDetail(requestInfo,businessServiceDetailCriteria); return getBusinessServiceDetailResponse(businessServiceDetails, requestInfo); } BusinessServiceDetailResponse searchBusinessServiceDetails(
final BusinessServiceDetailCriteria businessServiceDetailCriteria, final RequestInfo requestInfo); BusinessServiceDetailResponse create(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse createAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse updateAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse update(BusinessServiceDetailRequest businessServiceDetailRequest); static final Logger LOGGER; }### Answer:
@Test public void shouldSearchBusinessServiceDetails() { List<BusinessServiceDetail> businessServiceDetailList = new ArrayList<>(); businessServiceDetailList.add(getBusinessServiceDetail()); BusinessServiceDetailResponse businessServiceDetailResponse = new BusinessServiceDetailResponse(); businessServiceDetailResponse.setBusinessServiceDetails(businessServiceDetailList); BusinessServiceDetailCriteria businessServiceDetailCriteria = BusinessServiceDetailCriteria.builder().tenantId("ap").build(); when(businessServiceDetailRepository.searchBusinessServiceDetails(any(BusinessServiceDetailCriteria.class))).thenReturn(businessServiceDetailList); assertEquals(businessServiceDetailResponse, businessServDetailService.searchBusinessServiceDetails(businessServiceDetailCriteria, new RequestInfo())); }
|
### Question:
BusinessServDetailService { public BusinessServiceDetailResponse create(BusinessServiceDetailRequest businessServiceDetailRequest) { List<BusinessServiceDetail> businessServiceDetailList = businessServiceDetailRepository.create(businessServiceDetailRequest); return getBusinessServiceDetailResponse(businessServiceDetailList, businessServiceDetailRequest.getRequestInfo()); } BusinessServiceDetailResponse searchBusinessServiceDetails(
final BusinessServiceDetailCriteria businessServiceDetailCriteria, final RequestInfo requestInfo); BusinessServiceDetailResponse create(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse createAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse updateAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse update(BusinessServiceDetailRequest businessServiceDetailRequest); static final Logger LOGGER; }### Answer:
@Test public void shouldCreateBusinessServiceDetails() { List<BusinessServiceDetail> businessServiceDetailsForRequest = new ArrayList<>(); BusinessServiceDetail bizServDetail = getBusinessServiceDetail(); businessServiceDetailsForRequest.add(bizServDetail); BusinessServiceDetailRequest businessServiceDetailRequest = new BusinessServiceDetailRequest(); businessServiceDetailRequest.setBusinessServiceDetails(businessServiceDetailsForRequest); List<BusinessServiceDetail> businessServiceDetailsForResponse = new ArrayList<>(); businessServiceDetailsForResponse.add(bizServDetail); BusinessServiceDetailResponse businessServiceDetailResponse = new BusinessServiceDetailResponse(); businessServiceDetailResponse.setResponseInfo(null); businessServiceDetailResponse.setBusinessServiceDetails(businessServiceDetailsForResponse); when(businessServiceDetailRepository.create(any(BusinessServiceDetailRequest.class))).thenReturn(businessServiceDetailsForRequest); assertTrue(businessServiceDetailResponse.equals(businessServDetailService.create(businessServiceDetailRequest))); }
|
### Question:
BusinessServDetailService { public BusinessServiceDetailResponse updateAsync(BusinessServiceDetailRequest businessServiceDetailRequest) { List<BusinessServiceDetail> businessServiceDetailList = businessServiceDetailRequest.getBusinessServiceDetails(); kafkaTemplate.send(applicationProperties.getUpdateBusinessServiceDetailTopicName(), businessServiceDetailRequest); return getBusinessServiceDetailResponse(businessServiceDetailList, businessServiceDetailRequest.getRequestInfo()); } BusinessServiceDetailResponse searchBusinessServiceDetails(
final BusinessServiceDetailCriteria businessServiceDetailCriteria, final RequestInfo requestInfo); BusinessServiceDetailResponse create(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse createAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse updateAsync(BusinessServiceDetailRequest businessServiceDetailRequest); BusinessServiceDetailResponse update(BusinessServiceDetailRequest businessServiceDetailRequest); static final Logger LOGGER; }### Answer:
@Test public void shouldUpdateBusinessServiceDetails() { BusinessServiceDetailRequest businessServiceDetailRequest = new BusinessServiceDetailRequest(); List<BusinessServiceDetail> businessServiceDetails = new ArrayList<>(); businessServiceDetails.add(getBusinessServiceDetail()); businessServiceDetailRequest.setBusinessServiceDetails(businessServiceDetails); RequestInfo requestInfo = new RequestInfo(); User user = new User(); user.setId(1l); requestInfo.setUserInfo(user); businessServiceDetailRequest.setRequestInfo(requestInfo); BusinessServiceDetailResponse businessServiceDetailResponse = new BusinessServiceDetailResponse(); businessServiceDetailResponse.setResponseInfo(null); businessServiceDetailResponse.setBusinessServiceDetails(businessServiceDetails); assertTrue(businessServiceDetailResponse.equals(businessServDetailService.updateAsync(businessServiceDetailRequest))); }
|
### Question:
GlCodeMasterService { public GlCodeMasterResponse getGlCodes(GlCodeMasterCriteria searchGlCode, RequestInfo requestInfo) { logger.info("GlCodeMasterService getTaxHeads"); List<GlCodeMaster> glCodeMaster= glCodeMasterRepository.findForCriteria(searchGlCode); return getGlCodeMasterResponse(glCodeMaster,requestInfo); } GlCodeMasterResponse getGlCodes(GlCodeMasterCriteria searchGlCode, RequestInfo requestInfo); GlCodeMasterResponse create(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse createAsync(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse update(GlCodeMasterRequest request); GlCodeMasterResponse updateAsync(GlCodeMasterRequest request); }### Answer:
@Test public void testSearch() { List<GlCodeMaster> glCodeMasters = new ArrayList<>(); glCodeMasters.add(getGlCodeMaster()); GlCodeMasterResponse glCodeMasterResponse = new GlCodeMasterResponse(); glCodeMasterResponse.setGlCodeMasters(glCodeMasters); when(glCodeMasterRepository.findForCriteria(Matchers.any(GlCodeMasterCriteria.class))) .thenReturn(glCodeMasters); GlCodeMasterCriteria taxHeadMasterCriteria = GlCodeMasterCriteria.builder().tenantId("ap.kurnool").build(); assertEquals(glCodeMasterResponse, glCodeMasterService.getGlCodes(taxHeadMasterCriteria, new RequestInfo())); }
|
### Question:
GlCodeMasterService { public GlCodeMasterResponse createAsync(GlCodeMasterRequest glCodeMasterRequest) { List<GlCodeMaster> glCodeMaster = glCodeMasterRequest.getGlCodeMasters(); List<String> glCodeMasterIds = sequenceGenService.getIds(glCodeMaster.size(), applicationProperties.getGlCodeMasterseqName()); int index=0; for (GlCodeMaster master: glCodeMaster) { master.setId(glCodeMasterIds.get(index++)); } logger.info("glCodeMasterRequest createAsync::" + glCodeMasterRequest); kafkaTemplate.send(applicationProperties.getCreateGlCodeMasterTopicName(), applicationProperties.getCreateGlCodeMasterTopicKey(), glCodeMasterRequest); return getGlCodeMasterResponse(glCodeMaster, glCodeMasterRequest.getRequestInfo()); } GlCodeMasterResponse getGlCodes(GlCodeMasterCriteria searchGlCode, RequestInfo requestInfo); GlCodeMasterResponse create(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse createAsync(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse update(GlCodeMasterRequest request); GlCodeMasterResponse updateAsync(GlCodeMasterRequest request); }### Answer:
@Test public void testCreateAsync() { GlCodeMaster glCodeMaster = getGlCodeMaster(); GlCodeMasterRequest glCodeMasterRequest = new GlCodeMasterRequest(); List<GlCodeMaster> glCodeMasters = new ArrayList<>(); glCodeMasters.add(glCodeMaster); glCodeMasterRequest.setGlCodeMasters(glCodeMasters); GlCodeMasterResponse glCodeMasterResponse = new GlCodeMasterResponse(); glCodeMasterResponse.setResponseInfo(null); glCodeMasterResponse.setGlCodeMasters(glCodeMasters); List<String> ids=new ArrayList<>(); ids.add("12"); when(applicationProperties.getGlCodeMasterseqName()).thenReturn("seq_egbs_glcodemaster"); when(sequenceGenService.getIds(glCodeMasters.size(),applicationProperties.getGlCodeMasterseqName())).thenReturn(ids); when(sequenceGenService.getIds(any(Integer.class),any(String.class))).thenReturn(ids); assertTrue(glCodeMasterResponse.equals(glCodeMasterService.createAsync(glCodeMasterRequest))); }
|
### Question:
GlCodeMasterService { public GlCodeMasterResponse updateAsync(GlCodeMasterRequest request){ logger.info("glCodeMasterRequest updateAsync::" + request); kafkaTemplate.send(applicationProperties.getUpdateGlCodeMasterTopicName(), applicationProperties.getUpdateGlCodeMasterTopicKey(), request); return getGlCodeMasterResponse(request.getGlCodeMasters(), request.getRequestInfo()); } GlCodeMasterResponse getGlCodes(GlCodeMasterCriteria searchGlCode, RequestInfo requestInfo); GlCodeMasterResponse create(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse createAsync(GlCodeMasterRequest glCodeMasterRequest); GlCodeMasterResponse update(GlCodeMasterRequest request); GlCodeMasterResponse updateAsync(GlCodeMasterRequest request); }### Answer:
@Test public void testUpdateAsync() { GlCodeMaster glCodeMaster = getGlCodeMaster(); GlCodeMasterRequest glCodeMasterRequest = new GlCodeMasterRequest(); List<GlCodeMaster> glCodeMasters = new ArrayList<>(); glCodeMasters.add(glCodeMaster); glCodeMasterRequest.setGlCodeMasters(glCodeMasters); GlCodeMasterResponse glCodeMasterResponse = new GlCodeMasterResponse(); glCodeMasterResponse.setResponseInfo(null); glCodeMasterResponse.setGlCodeMasters(glCodeMasters); assertTrue(glCodeMasterResponse.equals(glCodeMasterService.updateAsync(glCodeMasterRequest))); }
|
### Question:
BusinessServiceDetailRepository { public List<BusinessServiceDetail> searchBusinessServiceDetails(final BusinessServiceDetailCriteria businessServiceDetailCriteria) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = businessServDetailQueryBuilder.prepareSearchQuery(businessServiceDetailCriteria, preparedStatementValues); List<BusinessServiceDetail> businessServiceDetailList = new ArrayList<>(); try { logger.info("queryStr -> " + queryStr + "preparedStatementValues -> " + preparedStatementValues.toString()); businessServiceDetailList = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), businessServDetailRowMapper); logger.info("BusinessServiceDetailRepository businessServiceDetailList -> " + businessServiceDetailList); } catch (final Exception ex) { logger.info("the exception from searchBusinessServiceDetails : " + ex); } return businessServiceDetailList; } List<BusinessServiceDetail> searchBusinessServiceDetails(final BusinessServiceDetailCriteria businessServiceDetailCriteria); List<BusinessServiceDetail> getBussinessServiceDetail(RequestInfo requestInfo,BusinessServiceDetailCriteria BusinessServiceDetailsCriteria); List<BusinessServiceDetail> create(BusinessServiceDetailRequest businessServiceDetailRequest); List<BusinessServiceDetail> update(BusinessServiceDetailRequest businessServiceDetailRequest); boolean checkForDuplicates(List<BusinessServiceDetail> businessServiceDetailList, String mode); }### Answer:
@Test public void shouldSearchForBusinessServiceDetails() { final List<Object> preparedStatementValues = new ArrayList<>(); final BusinessServiceDetailCriteria BusinessServiceDetailCriteria = Mockito.mock(BusinessServiceDetailCriteria.class); final String queryString = "testQuery"; when(businessServDetailQueryBuilder.prepareSearchQuery(BusinessServiceDetailCriteria, preparedStatementValues)).thenReturn(queryString); final List<BusinessServiceDetail> businessServiceDetailList = new ArrayList<>(); when(jdbcTemplate.query(queryString, preparedStatementValues.toArray(), businessServDetailRowMapper)) .thenReturn(businessServiceDetailList); assertTrue(businessServiceDetailList.equals(businessServiceDetailRepository.searchBusinessServiceDetails(BusinessServiceDetailCriteria))); }
|
### Question:
TaxHeadMasterRepository { public List<TaxHeadMaster> findForCriteria(TaxHeadMasterCriteria taxHeadMasterCriteria) { List<Object> preparedStatementValues = new ArrayList<>(); String queryStr = taxHeadMasterQueryBuilder.getQuery(taxHeadMasterCriteria, preparedStatementValues); return jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), taxHeadMasterRowMapper); } List<TaxHeadMaster> findForCriteria(TaxHeadMasterCriteria taxHeadMasterCriteria); List<TaxHeadMaster> getTaxHeadMaster(RequestInfo requestInfo, TaxHeadMasterCriteria taxHeadMasterCriteria); @Transactional List<TaxHeadMaster> create(TaxHeadMasterRequest taxHeadMasterRequest); @Transactional List<TaxHeadMaster> update(TaxHeadMasterRequest taxHeadMasterRequest); }### Answer:
@Test public void testFindForCriteria() { List<TaxHeadMaster> taxHeadMaster = new ArrayList<>(); taxHeadMaster.add(getTaxHeadMaster()); String query =""; when(taxHeadMasterQueryBuilder.getQuery(new TaxHeadMasterCriteria(),new ArrayList<>())).thenReturn(query); when(jdbcTemplate.query(any(String.class), any(Object[].class), any(TaxHeadMasterRowMapper.class))).thenReturn(taxHeadMaster); assertTrue(taxHeadMaster.equals(taxHeadMasterRepository.findForCriteria(new TaxHeadMasterCriteria()))); }
|
### Question:
TaxPeriodRepository { public List<TaxPeriod> searchTaxPeriods(final TaxPeriodCriteria taxPeriodCriteria) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = taxPeriodQueryBuilder.prepareSearchQuery(taxPeriodCriteria, preparedStatementValues); List<TaxPeriod> taxPeriods = new ArrayList<>(); try { log.info("queryStr -> " + queryStr + "preparedStatementValues -> " + preparedStatementValues.toString()); taxPeriods = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), taxPeriodRowMapper); log.info("TaxPeriodRepository taxPeriods -> " + taxPeriods); } catch (final Exception ex) { log.info("the exception from searchTaxPeriods : " + ex); } return taxPeriods; } List<TaxPeriod> searchTaxPeriods(final TaxPeriodCriteria taxPeriodCriteria); List<TaxPeriod> getTaxPeriod(RequestInfo requestInfo,TaxPeriodCriteria taxPeriodCriteria); List<TaxPeriod> create(TaxPeriodRequest taxPeriodRequest); List<TaxPeriod> update(TaxPeriodRequest taxPeriodRequest); boolean checkForDuplicates(List<TaxPeriod> taxPeriodList, String mode); }### Answer:
@Test public void shouldSearchForTaxPeriods() { final List<Object> preparedStatementValues = new ArrayList<>(); final TaxPeriodCriteria taxPeriodCriteria = Mockito.mock(TaxPeriodCriteria.class); final String queryString = "testQuery"; when(taxPeriodQueryBuilder.prepareSearchQuery(taxPeriodCriteria, preparedStatementValues)).thenReturn(queryString); final List<TaxPeriod> taxPeriods = new ArrayList<>(); when(jdbcTemplate.query(queryString, preparedStatementValues.toArray(), taxPeriodRowMapper)) .thenReturn(taxPeriods); assertTrue(taxPeriods.equals(taxPeriodRepository.searchTaxPeriods(taxPeriodCriteria))); }
|
### Question:
GlCodeMasterRepository { public List<GlCodeMaster> findForCriteria(GlCodeMasterCriteria glCodeMasterCriteria) { List<Object> preparedStatementValues = new ArrayList<>(); String queryStr = glCodeMasterQueryBuilder.getQuery(glCodeMasterCriteria, preparedStatementValues); List<GlCodeMaster> glCodeMaster = null; try { log.info("queryStr::" + queryStr + "preparedStatementValues::" + preparedStatementValues.toString()); glCodeMaster = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), glCodeMasterRowMapper); log.info("GlCodeMasterRepository::" + glCodeMaster); } catch (Exception ex) { log.info("the exception from findforcriteria : " + ex); } return glCodeMaster; } List<GlCodeMaster> findForCriteria(GlCodeMasterCriteria glCodeMasterCriteria); @Transactional void create(GlCodeMasterRequest glCodeMasterRequest); void update(GlCodeMasterRequest glCodeMasterRequest); }### Answer:
@Test public void testFindForCriteria() { List<GlCodeMaster> glCodeMaster = new ArrayList<>(); glCodeMaster.add(getGlCodeMaster()); String query =""; when(glCodeMasterQueryBuilder.getQuery(new GlCodeMasterCriteria(),new ArrayList<>())).thenReturn(query); when(jdbcTemplate.query(any(String.class), any(Object[].class), any(GlCodeMasterRowMapper.class))).thenReturn(glCodeMaster); assertTrue(glCodeMaster.equals(glCodeMasterRepository.findForCriteria(new GlCodeMasterCriteria()))); }
|
### Question:
NomineeService { public List<Nominee> createAsync(NomineeRequest nomineeRequest) throws JsonProcessingException { populateDataForSave(nomineeRequest.getNominees(), nomineeRequest.getRequestInfo()); create(nomineeRequest); return nomineeRequest.getNominees(); } List<Nominee> getNominees(NomineeGetRequest nomineeGetRequest, RequestInfo requestInfo); List<Nominee> createAsync(NomineeRequest nomineeRequest); @Transactional void create(NomineeRequest nomineeRequest); List<Nominee> updateAsync(NomineeRequest nomineeRequest); @Transactional void update(NomineeRequest nomineeRequest); }### Answer:
@Test public void testCreateAsync() throws JsonProcessingException { List<Nominee> expectedNominees = seedHelper.getNominees(); doReturn(Arrays.asList(1L)).when(nomineeRepository).generateSequences(anyInt()); List<Nominee> actualNominees = nomineeService.createAsync(seedHelper.getNomineeRequest()); verify(nomineeRepository).generateSequences(anyInt()); verify(nomineeRepository).save(anyListOf(Nominee.class)); assertEquals(expectedNominees, actualNominees); }
|
### Question:
NomineeService { @Transactional public void create(NomineeRequest nomineeRequest) { List<Nominee> nominees = nomineeRequest.getNominees(); nomineeRepository.save(nominees); } List<Nominee> getNominees(NomineeGetRequest nomineeGetRequest, RequestInfo requestInfo); List<Nominee> createAsync(NomineeRequest nomineeRequest); @Transactional void create(NomineeRequest nomineeRequest); List<Nominee> updateAsync(NomineeRequest nomineeRequest); @Transactional void update(NomineeRequest nomineeRequest); }### Answer:
@Test public void testCreate() throws JsonProcessingException { doNothing().when(nomineeRepository).save(anyListOf(Nominee.class)); nomineeService.create(seedHelper.getNomineeRequest()); verify(nomineeRepository).save(anyListOf(Nominee.class)); }
|
### Question:
NomineeService { public List<Nominee> updateAsync(NomineeRequest nomineeRequest) throws JsonProcessingException { populateDataForUpdate(nomineeRequest.getNominees(), nomineeRequest.getRequestInfo()); update(nomineeRequest); return nomineeRequest.getNominees(); } List<Nominee> getNominees(NomineeGetRequest nomineeGetRequest, RequestInfo requestInfo); List<Nominee> createAsync(NomineeRequest nomineeRequest); @Transactional void create(NomineeRequest nomineeRequest); List<Nominee> updateAsync(NomineeRequest nomineeRequest); @Transactional void update(NomineeRequest nomineeRequest); }### Answer:
@Test public void testUpdateAsync() throws JsonProcessingException { List<Nominee> expectedNominees = seedHelper.getNominees(); List<Nominee> actualNominees = nomineeService.updateAsync(seedHelper.getNomineeRequest()); verify(nomineeRepository).update(anyListOf(Nominee.class)); assertEquals(expectedNominees, actualNominees); }
|
### Question:
NomineeService { @Transactional public void update(NomineeRequest nomineeRequest) { nomineeRepository.update(nomineeRequest.getNominees()); documentsService.updateDocumentsForNominee(nomineeRequest.getNominees()); } List<Nominee> getNominees(NomineeGetRequest nomineeGetRequest, RequestInfo requestInfo); List<Nominee> createAsync(NomineeRequest nomineeRequest); @Transactional void create(NomineeRequest nomineeRequest); List<Nominee> updateAsync(NomineeRequest nomineeRequest); @Transactional void update(NomineeRequest nomineeRequest); }### Answer:
@Test public void testUpdate() throws JsonProcessingException { doNothing().when(nomineeRepository).update(anyListOf(Nominee.class)); doNothing().when(documentsService).updateDocumentsForNominee(anyListOf(Nominee.class)); nomineeService.update(seedHelper.getNomineeRequest()); verify(nomineeRepository).update(anyListOf(Nominee.class)); verify(documentsService).updateDocumentsForNominee(anyListOf(Nominee.class)); }
|
### Question:
MovementService { public MovementRequest create(final MovementRequest movementRequest) { movementRequest.getMovement().get(0).setId(movementRepository.generateSequence()); return movementRepository.saveMovement(movementRequest); } List<Movement> getMovements(final MovementSearchRequest movementSearchRequest,
final RequestInfo requestInfo); ResponseEntity<?> createMovements(final MovementRequest movementRequest, final String type); ResponseEntity<?> getSuccessResponseForCreate(final List<Movement> movementsList,
final RequestInfo requestInfo); MovementRequest create(final MovementRequest movementRequest); ResponseEntity<?> updateMovement(final MovementRequest movementRequest); Movement update(final MovementRequest movementRequest); Boolean checkEmployeeExists(final MovementRequest movementRequest); static final Logger LOGGER; }### Answer:
@Test public void test_movement_service_repository_should_create_movement() { Movement movement1 = new Movement(); movement1.setId(1L); movement1.setEmployeeId(1L); movement1.setPositionAssigned(1L); movements = new ArrayList<>(); movements.add(movement1); final MovementRequest movementRequest = new MovementRequest(); movementRequest.setMovement(movements); movementRequest.setRequestInfo(requestInfo); when(movementRepository.saveMovement(Mockito.any(MovementRequest.class))).thenReturn(movementRequest); final MovementRequest result = movementService.create(movementRequest); assertEquals(result.getMovement().size(), movementRequest.getMovement().size()); }
|
### Question:
DesignationService { public List<Designation> getDesignations(DesignationGetRequest designationGetRequest) { return designationRepository.findForCriteria(designationGetRequest); } List<Designation> getDesignations(DesignationGetRequest designationGetRequest); List<Designation> getDesignationsFromMDMS(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); MdmsCriteriaReq prepareSearchRequestForDesignation(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); ResponseEntity<?> createDesignation(DesignationRequest designationRequest); ResponseEntity<?> updateDesignation(DesignationRequest designationRequest); ResponseEntity<?> getSuccessResponseForCreate(List<Designation> designationList,
RequestInfo requestInfo); void create(DesignationRequest designationRequest); void update(DesignationRequest designationRequest); }### Answer:
@Test public void test_getDesignation() { DesignationGetRequest criteria = new DesignationGetRequest().builder().tenantId("default").code("100").active(true).build(); when(designationRepository.findForCriteria(criteria)).thenReturn(designations); List<Designation> result = designationService.getDesignations(criteria); assertThat(result).isEqualTo(designations); }
|
### Question:
DesignationService { public ResponseEntity<?> createDesignation(DesignationRequest designationRequest) { Designation designation = designationRequest.getDesignation(); designation.setId(commonIdGenerationService.getNextId(Sequence.DESIGNATIONSEQUENCS)); create(designationRequest); return getSuccessResponseForCreate(Collections.singletonList(designation), designationRequest.getRequestInfo()); } List<Designation> getDesignations(DesignationGetRequest designationGetRequest); List<Designation> getDesignationsFromMDMS(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); MdmsCriteriaReq prepareSearchRequestForDesignation(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); ResponseEntity<?> createDesignation(DesignationRequest designationRequest); ResponseEntity<?> updateDesignation(DesignationRequest designationRequest); ResponseEntity<?> getSuccessResponseForCreate(List<Designation> designationList,
RequestInfo requestInfo); void create(DesignationRequest designationRequest); void update(DesignationRequest designationRequest); }### Answer:
@Test public void test_createDesignation() { RequestInfo requestInfo = new RequestInfo().builder().apiId("emp").build(); Designation designation = new Designation().builder().id(10L).active(true).chartOfAccounts("accounts").code("100").description("account designation").build(); DesignationRequest designationRequest = new DesignationRequest().builder().requestInfo(requestInfo).designation(designation).build(); ResponseInfo expectedResponseInfo = new ResponseInfo("emp", "1.0", "2017-01-18T07:18:23.130Z", "uief87324", "20170310130900", "200"); when(responseInfoFactory.createResponseInfoFromRequestInfo(any(RequestInfo.class),any(Boolean.class))).thenReturn(expectedResponseInfo); when(commonIdGenerationService.getNextId(any(Sequence.class))).thenReturn(Long.valueOf("10")); ResponseEntity<?> response = designationService.createDesignation(designationRequest); assertEquals(response.getStatusCode().toString(),"200"); }
|
### Question:
DesignationService { public ResponseEntity<?> updateDesignation(DesignationRequest designationRequest) { Designation designation = designationRequest.getDesignation(); update(designationRequest); return getSuccessResponseForCreate(Collections.singletonList(designation), designationRequest.getRequestInfo()); } List<Designation> getDesignations(DesignationGetRequest designationGetRequest); List<Designation> getDesignationsFromMDMS(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); MdmsCriteriaReq prepareSearchRequestForDesignation(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); ResponseEntity<?> createDesignation(DesignationRequest designationRequest); ResponseEntity<?> updateDesignation(DesignationRequest designationRequest); ResponseEntity<?> getSuccessResponseForCreate(List<Designation> designationList,
RequestInfo requestInfo); void create(DesignationRequest designationRequest); void update(DesignationRequest designationRequest); }### Answer:
@Test public void test_updateDesignation() { RequestInfo requestInfo = new RequestInfo().builder().apiId("emp").build(); Designation designation = new Designation().builder().id(10L).active(true).chartOfAccounts("accounts").code("100").description("account designation").build(); DesignationRequest designationRequest = new DesignationRequest().builder().requestInfo(requestInfo).designation(designation).build(); ResponseInfo expectedResponseInfo = new ResponseInfo("emp", "1.0", "2017-01-18T07:18:23.130Z", "uief87324", "20170310130900", "200"); when(responseInfoFactory.createResponseInfoFromRequestInfo(any(RequestInfo.class),any(Boolean.class))).thenReturn(expectedResponseInfo); ResponseEntity<?> response = designationService.updateDesignation(designationRequest); assertEquals(response.getStatusCode().toString(),"200"); }
|
### Question:
DesignationService { public void create(DesignationRequest designationRequest) { designationRepository.create(designationRequest); } List<Designation> getDesignations(DesignationGetRequest designationGetRequest); List<Designation> getDesignationsFromMDMS(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); MdmsCriteriaReq prepareSearchRequestForDesignation(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); ResponseEntity<?> createDesignation(DesignationRequest designationRequest); ResponseEntity<?> updateDesignation(DesignationRequest designationRequest); ResponseEntity<?> getSuccessResponseForCreate(List<Designation> designationList,
RequestInfo requestInfo); void create(DesignationRequest designationRequest); void update(DesignationRequest designationRequest); }### Answer:
@Test public void test_create() { RequestInfo requestInfo = new RequestInfo().builder().apiId("emp").build(); Designation designation = new Designation().builder().id(10L).active(true).chartOfAccounts("accounts").code("100").description("account designation").build(); DesignationRequest designationRequest = new DesignationRequest().builder().requestInfo(requestInfo).designation(designation).build(); designationService.create(designationRequest); verify(designationRepository).create(any(DesignationRequest.class)); }
|
### Question:
DesignationService { public void update(DesignationRequest designationRequest) { designationRepository.update(designationRequest); } List<Designation> getDesignations(DesignationGetRequest designationGetRequest); List<Designation> getDesignationsFromMDMS(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); MdmsCriteriaReq prepareSearchRequestForDesignation(RequestInfo requestInfo, DesignationGetRequest designationGetRequest); ResponseEntity<?> createDesignation(DesignationRequest designationRequest); ResponseEntity<?> updateDesignation(DesignationRequest designationRequest); ResponseEntity<?> getSuccessResponseForCreate(List<Designation> designationList,
RequestInfo requestInfo); void create(DesignationRequest designationRequest); void update(DesignationRequest designationRequest); }### Answer:
@Test public void test_update() { RequestInfo requestInfo = new RequestInfo().builder().apiId("emp").build(); Designation designation = new Designation().builder().id(10L).active(true).chartOfAccounts("accounts").code("100").description("account designation").build(); DesignationRequest designationRequest = new DesignationRequest().builder().requestInfo(requestInfo).designation(designation).build(); designationService.update(designationRequest); verify(designationRepository).update(any(DesignationRequest.class)); }
|
### Question:
PositionHierarchyService { public List<PositionHierarchy> getPositionHierarchies(PositionHierarchyGetRequest positionHierarchyGetRequest) { return positionHierarchyRepository.findForCriteria(positionHierarchyGetRequest); } List<PositionHierarchy> getPositionHierarchies(PositionHierarchyGetRequest positionHierarchyGetRequest); }### Answer:
@Test public void test_getPositionHierarchy() { List<PositionHierarchy> positionHierarchies = new ArrayList<>(); when(positionHierarchyRepository.findForCriteria(any(PositionHierarchyGetRequest.class))).thenReturn(positionHierarchies); List<PositionHierarchy> result = positionHierarchyService.getPositionHierarchies(any(PositionHierarchyGetRequest.class)); assertThat(result).isEqualTo(positionHierarchies); }
|
### Question:
GroupService { public List<Group> getGroups(GroupGetRequest groupGetRequest) { return groupRepository.findForCriteria(groupGetRequest); } List<Group> getGroups(GroupGetRequest groupGetRequest); }### Answer:
@Test public void test_getGroups() { List<Group> groups = new ArrayList<>(); when(groupRepository.findForCriteria(any(GroupGetRequest.class))).thenReturn(groups); List<Group> result = groupService.getGroups(any(GroupGetRequest.class)); assertThat(result).isEqualTo(groups); }
|
### Question:
ObjectTypeService { public ObjectType getObjectType(Long id) { return objectTypeRepository.findForId(id); } ObjectType getObjectType(Long id); }### Answer:
@Test public void test_getObjectType() { ObjectType objectType = new ObjectType(); when(objectTypeRepository.findForId(any(Long.class))).thenReturn(objectType); ObjectType result = objectTypeService.getObjectType(any(Long.class)); assertThat(result).isEqualTo(objectType); }
|
### Question:
RecruitmentTypeService { public List<RecruitmentType> getRecruitmentTypes(RecruitmentTypeGetRequest recruitmentTypeGetRequest) { return recruitmentTypeRepository.findForCriteria(recruitmentTypeGetRequest); } List<RecruitmentType> getRecruitmentTypes(RecruitmentTypeGetRequest recruitmentTypeGetRequest); }### Answer:
@Test public void test_getRecruitmentTypes() { List<RecruitmentType> recruitmentTypes = new ArrayList<>(); when(recruitmentTypeRepository.findForCriteria(any(RecruitmentTypeGetRequest.class))).thenReturn(recruitmentTypes); List<RecruitmentType> result = recruitmentTypeService.getRecruitmentTypes(any(RecruitmentTypeGetRequest.class)); assertThat(result).isEqualTo(recruitmentTypes); }
|
### Question:
DepartmentDesignationService { public DepartmentDesignation getDepartmentDesignation(Long id) { return departmentDesignationRepository.findForId(id); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(String departmentCode, String designationCode, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_getDepartmentDesignation() { DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentCode("code").id(1L).tenantId("default").build(); when(departmentDesignationRepository.findForId(any(Long.class))).thenReturn(departmentDesignation); DepartmentDesignation result = departmentDesignationService.getDepartmentDesignation(1L); assertThat(result).isEqualTo(departmentDesignation); }
|
### Question:
DepartmentDesignationService { public DepartmentDesignation getByDepartmentAndDesignation(String departmentCode, String designationCode, String tenantId) { return departmentDesignationRepository.findByDepartmentAndDesignation(departmentCode, designationCode, tenantId); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(String departmentCode, String designationCode, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_getByDepartmentAndDesignation(){ DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentCode("code").id(1L).tenantId("default").build(); when(departmentDesignationRepository.findByDepartmentAndDesignation(any(String.class), any(String.class), any(String.class))).thenReturn(departmentDesignation); DepartmentDesignation result = departmentDesignationService.getByDepartmentAndDesignation("dept", "desg", "default"); assertThat(result).isEqualTo(departmentDesignation); }
|
### Question:
DepartmentDesignationService { public void create(DepartmentDesignation departmentDesignation) { departmentDesignationRepository.create(departmentDesignation); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(String departmentCode, String designationCode, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_create() { DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentCode("code").id(1L).tenantId("default").build(); doNothing().when(departmentDesignationRepository).create(any(DepartmentDesignation.class)); departmentDesignationService.create(departmentDesignation); verify(departmentDesignationRepository).create(any(DepartmentDesignation.class)); }
|
### Question:
HRStatusService { public List<HRStatus> getHRStatuses(HRStatusGetRequest hrStatusGetRequest) { return hrStatusRepository.findForCriteria(hrStatusGetRequest); } List<HRStatus> getHRStatuses(HRStatusGetRequest hrStatusGetRequest); }### Answer:
@Test public void test_getHrStatus() { List<HRStatus> hrServices = new ArrayList<>(); when(hrStatusRepository.findForCriteria(any(HRStatusGetRequest.class))).thenReturn(hrServices); List<HRStatus> result = hrStatusService.getHRStatuses(any(HRStatusGetRequest.class)); assertThat(result).isEqualTo(hrServices); }
|
### Question:
RecruitmentModeService { public List<RecruitmentMode> getRecruitmentModes(RecruitmentModeGetRequest recruitmentModeGetRequest) { return recruitmentModeRepository.findForCriteria(recruitmentModeGetRequest); } List<RecruitmentMode> getRecruitmentModes(RecruitmentModeGetRequest recruitmentModeGetRequest); }### Answer:
@Test public void test_getRecruitmentModes() { List<RecruitmentMode> recruitmentModes = new ArrayList<>(); when(recruitmentModeRepository.findForCriteria(any(RecruitmentModeGetRequest.class))).thenReturn(recruitmentModes); List<RecruitmentMode> result = recruitmentModeService.getRecruitmentModes(any(RecruitmentModeGetRequest.class)); assertThat(result).isEqualTo(recruitmentModes); }
|
### Question:
GradeService { public List<Grade> getGrades(GradeGetRequest gradeGetRequest) { return gradeRepository.findForCriteria(gradeGetRequest); } List<Grade> getGrades(GradeGetRequest gradeGetRequest); }### Answer:
@Test public void test_getGrades() { List<Grade> grades = new ArrayList<>(); when(gradeRepository.findForCriteria(any(GradeGetRequest.class))).thenReturn(grades); List<Grade> result = gradeService.getGrades(any(GradeGetRequest.class)); assertThat(result).isEqualTo(grades); }
|
### Question:
HRConfigurationService { public Map<String, List<String>> getHRConfigurations(HRConfigurationGetRequest hrConfigurationGetRequest) { return hrConfigurationRepository.findForCriteria(hrConfigurationGetRequest); } Map<String, List<String>> getHRConfigurations(HRConfigurationGetRequest hrConfigurationGetRequest); }### Answer:
@Test public void test_getHrConfigs() { Map<String, List<String>> hrConfigurations = new HashMap<>(); when(hrConfigurationRepository.findForCriteria(any(HRConfigurationGetRequest.class))).thenReturn(hrConfigurations); Map<String, List<String>> result = hrConfigurationService.getHRConfigurations(any(HRConfigurationGetRequest.class)); assertThat(result).isEqualTo(hrConfigurations); }
|
### Question:
EmployeeTypeService { public List<EmployeeType> getEmployeeTypes(EmployeeTypeGetRequest employeeTypeGetRequest) { return employeeTypeRepository.findForCriteria(employeeTypeGetRequest); } List<EmployeeType> getEmployeeTypes(EmployeeTypeGetRequest employeeTypeGetRequest); }### Answer:
@Test public void test_getEmployeeTypes() { List<EmployeeType> employeeTypes = new ArrayList<>(); when(employeeTypeRepository.findForCriteria(any(EmployeeTypeGetRequest.class))).thenReturn(employeeTypes); List<EmployeeType> result = employeeTypeService.getEmployeeTypes(any(EmployeeTypeGetRequest.class)); assertThat(result).isEqualTo(employeeTypes); }
|
### Question:
RecruitmentQuotaService { public List<RecruitmentQuota> getRecruitmentQuotas(RecruitmentQuotaGetRequest recruitmentQuotaGetRequest) { return recruitmentQuotaRepository.findForCriteria(recruitmentQuotaGetRequest); } List<RecruitmentQuota> getRecruitmentQuotas(RecruitmentQuotaGetRequest recruitmentQuotaGetRequest); }### Answer:
@Test public void test_getRecruitmentQuotas() { List<RecruitmentQuota> recruitmentQuotas = new ArrayList<>(); when(recruitmentQuotaRepository.findForCriteria(any(RecruitmentQuotaGetRequest.class))).thenReturn(recruitmentQuotas); List<RecruitmentQuota> result = recruitmentQuotaService.getRecruitmentQuotas(any(RecruitmentQuotaGetRequest.class)); assertThat(result).isEqualTo(recruitmentQuotas); }
|
### Question:
CommonMasterService { private HttpEntity<RequestInfoWrapper> getRequestInfoAsHttpEntity(RequestInfoWrapper requestInfoWrapper) { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<RequestInfoWrapper> httpEntityRequest = new HttpEntity<RequestInfoWrapper>(requestInfoWrapper, headers); return httpEntityRequest; } Religion getReligion(Long id, String tenantId, RequestInfoWrapper requestInfoWrapper); List<Language> getLanguages(List<Long> ids, String tenantId, RequestInfoWrapper requestInfoWrapper); Community getCommunity(Long id, String tenantId, RequestInfoWrapper requestInfoWrapper); Category getCategory(Long id, String tenantId, RequestInfoWrapper requestInfoWrapper); Department getDepartment(Long id, String tenantId, RequestInfoWrapper requestInfoWrapper); static final Logger LOGGER; }### Answer:
@Test public void testGetLanguage() { ResponseInfo responseInfo = new ResponseInfo("emp", "1.0", "2017-01-18T07:18:23.130Z", "uief87324", "20170310130900", "200"); Language language = new Language().builder().id(100L).name("employee1").tenantId("1").build(); List<Language> languages = new ArrayList<>(); languages.add(language); LanguageResponse languageResponse = LanguageResponse.builder().responseInfo(responseInfo) .language(languages).build(); when(propertiesManager.getEgovCommonMastersServiceHost()).thenReturn("http: when(propertiesManager.getEgovCommonMastersServiceBasepath()).thenReturn("/egov-common-masters"); when(propertiesManager.getEgovCommonMastersServiceLanguageSearchPath()).thenReturn("/languages/_search"); RequestInfoWrapper requestInfoWrapper = new RequestInfoWrapper(); URI uri = null; try { uri = new URI( "http: } catch (URISyntaxException e) { e.printStackTrace(); } when(restTemplate.postForObject(uri, getRequestInfoAsHttpEntity(requestInfoWrapper), LanguageResponse.class)) .thenReturn(languageResponse); }
|
### Question:
BoundaryService { public Boundary getBoundary(Long id, String tenantId) { BoundaryResponse boundaryResponse; try { URI url = new URI(propertiesManager.getEgovLocationServiceHost() + propertiesManager.getEgovLocationServiceBasepath() + propertiesManager.getEgovLocationServiceBoundarySearchPath() + "?Boundary.tenantId=" + tenantId + "&Boundary.id=" + id); log.info(url.toString()); boundaryResponse = restTemplate.getForObject(url, BoundaryResponse.class); } catch (Exception e) { e.printStackTrace(); return null; } return isEmpty(boundaryResponse.getBoundarys()) ? null : boundaryResponse.getBoundarys().get(0); } Boundary getBoundary(Long id, String tenantId); }### Answer:
@Test public void testGetBoundary() { ResponseInfo responseInfo = new ResponseInfo("emp", "1.0", "2017-01-18T07:18:23.130Z", "uief87324", "20170310130900", "200"); Boundary boundary = Boundary.builder().id("10").name("employee").tenantId("default").build(); BoundaryResponse boundaryResponse = BoundaryResponse.builder().responseInfo(responseInfo) .boundarys(Collections.singletonList(boundary)).build(); when(propertiesManager.getEgovLocationServiceHost()).thenReturn("http: when(propertiesManager.getEgovLocationServiceBasepath()).thenReturn("/egov-location"); when(propertiesManager.getEgovLocationServiceBoundarySearchPath()).thenReturn("/boundarys"); RequestInfoWrapper requestInfoWrapper = new RequestInfoWrapper(); URI uri = null; try { uri = new URI("http: } catch (URISyntaxException e) { e.printStackTrace(); } when(restTemplate.getForObject(uri, BoundaryResponse.class)).thenReturn(boundaryResponse); Boundary insertedBoundary = boundaryService.getBoundary(10L, "default"); assertEquals(insertedBoundary, boundary); }
|
### Question:
RequestBodyInspector { @SuppressWarnings("unchecked") public HashMap<String, Object> getRequestInfo() { if (isRequestInfoPresent()) { return (HashMap<String, Object>) requestBody.get(getRequestInfoFieldNamePresent()); } return null; } RequestBodyInspector(HashMap<String, Object> requestBody); boolean isRequestInfoPresent(); HashMap<String, Object> getRequestBody(); void updateRequestInfo(HashMap<String, Object> requestInfo); @SuppressWarnings("unchecked") HashMap<String, Object> getRequestInfo(); }### Answer:
@Test public void test_should_return_request_info_when_request_info_container_field_name_has_pascal_case() { final HashMap<String, Object> requestBody = new HashMap<>(); final HashMap<Object, Object> requestInfoBody = new HashMap<>(); requestBody.put("RequestInfo", requestInfoBody); final RequestBodyInspector requestBodyInspector = new RequestBodyInspector(requestBody); assertEquals(requestInfoBody, requestBodyInspector.getRequestInfo()); }
@Test public void test_should_return_request_info_when_request_info_container_field_name_has_camel_case() { final HashMap<String, Object> requestBody = new HashMap<>(); final HashMap<Object, Object> requestInfoBody = new HashMap<>(); requestBody.put("requestInfo", requestInfoBody); final RequestBodyInspector requestBodyInspector = new RequestBodyInspector(requestBody); assertEquals(requestInfoBody, requestBodyInspector.getRequestInfo()); }
@Test public void test_should_return_null_when_request_body_is_empty() { final HashMap<String, Object> requestBody = new HashMap<>(); final RequestBodyInspector requestBodyInspector = new RequestBodyInspector(requestBody); assertNull(requestBodyInspector.getRequestInfo()); }
@Test public void test_should_return_null_when_request_body_does_not_have_request_info() { final HashMap<String, Object> requestBody = new HashMap<>(); requestBody.put("someField", new HashMap<>()); final RequestBodyInspector requestBodyInspector = new RequestBodyInspector(requestBody); assertNull(requestBodyInspector.getRequestInfo()); }
|
### Question:
AuthFilter extends ZuulFilter { @Override public boolean shouldFilter() { return RequestContext.getCurrentContext().getBoolean(AUTH_BOOLEAN_FLAG_NAME); } AuthFilter(ProxyRequestHelper helper, RestTemplate restTemplate, String authServiceHost, String authUri); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void testThatFilterShouldBeAppliedBasedOnContext() { RequestContext ctx = RequestContext.getCurrentContext(); ctx.set("shouldDoAuth", false); assertFalse(authFilter.shouldFilter()); ctx.set("shouldDoAuth", true); assertTrue(authFilter.shouldFilter()); }
|
### Question:
AuthFilter extends ZuulFilter { @Override public Object run() { RequestContext ctx = RequestContext.getCurrentContext(); String authToken = (String) ctx.get(AUTH_TOKEN_KEY); try { User user = getUser(authToken, ctx); ctx.set(USER_INFO_KEY, user); } catch (HttpClientErrorException ex) { logger.error(RETRIEVING_USER_FAILED_MESSAGE, ex); ExceptionUtils.RaiseException(ex); } catch (ResourceAccessException ex) { logger.error(RETRIEVING_USER_FAILED_MESSAGE, ex); ExceptionUtils.raiseCustomException(HttpStatus.INTERNAL_SERVER_ERROR, "User authentication service is down"); } return null; } AuthFilter(ProxyRequestHelper helper, RestTemplate restTemplate, String authServiceHost, String authUri); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void testThatFilterShouldAbortIfValidatingAuthTokenFails() throws IOException { RequestContext ctx = RequestContext.getCurrentContext(); String authToken = "dummy-auth-token"; ctx.set("authToken", authToken); request.setMethod("POST"); ctx.setRequest(request); ctx.setResponse(new MockHttpServletResponse()); String authUrl = String.format("%s%s%s", authServiceHost, authUri, authToken); when(restTemplate.postForObject(eq(authUrl), any(), eq(User.class))) .thenThrow(new HttpClientErrorException(HttpStatus.UNAUTHORIZED)); try { authFilter.run(); assertFalse("Shouldn't reach here", true ); } catch (RuntimeException ex) { assertThat(((HttpClientErrorException)ex.getCause()).getStatusCode().value(), is(401)); } }
|
### Question:
RbacPreCheckFilter extends ZuulFilter { @Override public Object run() { if ((openEndpointsWhitelist.contains(getRequestURI()) || anonymousEndpointsWhitelist.contains(getRequestURI()))) { setShouldDoRbac(false); logger.info(SKIP_RBAC, getRequestURI()); return null; } setShouldDoRbac(true); return null; } @Autowired RbacPreCheckFilter(HashSet<String> openEndpointsWhitelist,
HashSet<String> anonymousEndpointsWhitelist); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void testThatRbacCheckShouldNotHappenForOpenEndpoints() { RequestContext ctx = RequestContext.getCurrentContext(); request.setRequestURI("/user/_details"); ctx.setRequest(request); rbacPreCheckFilter.run(); assertFalse((Boolean) ctx.get("shouldDoRbac")); }
@Test public void test_That_Rbac_Check_Sould_Not_Happen_For_AnonymousEndPoints(){ RequestContext ctx = RequestContext.getCurrentContext(); request.setRequestURI("/pgr/complaintTypeCategories"); ctx.setRequest(request); rbacPreCheckFilter.run(); assertFalse((Boolean) ctx.get("shouldDoRbac")); }
@Test public void test_should_return_true_when_uri_is_not_in_open_or_anonymous_endpoint_and_uri_is_present_in_rbacwhitelist() throws Exception { RequestContext ctx = RequestContext.getCurrentContext(); request.setRequestURI("/pgr/seva/_create"); ctx.setRequest(request); rbacPreCheckFilter.run(); assertTrue((Boolean) ctx.get("shouldDoRbac")); }
|
### Question:
RbacFilter extends ZuulFilter { @Override public int filterOrder() { return 4; } @Autowired RbacFilter(RestTemplate restTemplate, String authorizationUrl, ObjectMapper objectMapper); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void testThatFilterOrderIs3() throws Exception { assertThat(rbacFilter.filterOrder(), is(4)); }
|
### Question:
RbacFilter extends ZuulFilter { @Override public boolean shouldFilter() { RequestContext ctx = RequestContext.getCurrentContext(); return ctx.getBoolean(RBAC_BOOLEAN_FLAG_NAME); } @Autowired RbacFilter(RestTemplate restTemplate, String authorizationUrl, ObjectMapper objectMapper); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void testThatFilterShouldNotRunWhenRbacIsNotRequired() throws Exception { RequestContext ctx = RequestContext.getCurrentContext(); ctx.set("shouldDoRbac", false); assertFalse(rbacFilter.shouldFilter()); }
|
### Question:
RequestEnrichmentFilter extends ZuulFilter { @Override public int filterOrder() { return 5; } RequestEnrichmentFilter(); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_set_filter_order_to_execute_last() { assertEquals(5, filter.filterOrder()); }
|
### Question:
RequestEnrichmentFilter extends ZuulFilter { @Override public boolean shouldFilter() { return true; } RequestEnrichmentFilter(); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_always_execute_filter() { assertTrue(filter.shouldFilter()); }
|
### Question:
RequestEnrichmentFilter extends ZuulFilter { @Override public Object run() { modifyRequestBody(); addRequestHeaders(); return null; } RequestEnrichmentFilter(); @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_add_correlation_id_request_header() { final RequestContext currentContext = RequestContext.getCurrentContext(); final MockHttpServletRequest request = new MockHttpServletRequest(); request.setMethod("GET"); currentContext.setRequest(request); final String expectedCorrelationId = "someCorrelationId"; currentContext.set("CORRELATION_ID", expectedCorrelationId); filter.run(); final Map<String, String> zuulRequestHeaders = currentContext.getZuulRequestHeaders(); assertEquals(2, zuulRequestHeaders.size()); assertEquals(expectedCorrelationId, zuulRequestHeaders.get("x-correlation-id")); }
@Test public void test_should_add_correlation_id_to_request_info_section_of_request_body() throws IOException { final RequestContext currentContext = RequestContext.getCurrentContext(); final MockHttpServletRequest request = new MockHttpServletRequest(); request.setMethod("POST"); request.setRequestURI("http: request.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE); request.setContent(getContent("postRequestFromConsumer.json")); currentContext.setRequest(request); final String expectedCorrelationId = "someCorrelationId"; currentContext.set("CORRELATION_ID", expectedCorrelationId); currentContext.set("USER_INFO", null); filter.run(); String expectedBody = resources.getFileContents("postRequestWithCorrelationId.json"); assertEquals(expectedBody, IOUtils.toString(currentContext.getRequest().getInputStream())); }
|
### Question:
TradeLicenseJdbcRepository extends JdbcRepository { public TradeLicenseEntity create(TradeLicenseEntity entity) { super.create(entity); return entity; } TradeLicenseEntity create(TradeLicenseEntity entity); TradeLicenseEntity update(TradeLicenseEntity entity); List<TradeLicenseEntity> search(LicenseSearch domain); Long getLicenseApplicationId(Long licenseId); Long getLicenseBillId(Long licenseId); Long getApplicationBillId(Long licenseId); @Autowired
public NamedParameterJdbcTemplate namedParameterJdbcTemplate; }### Answer:
@Test @Sql(scripts = { "/sql/clearLicense.sql" }) public void testCreate() { TradeLicenseEntity tradeLicenseEntity = getTradeLicenseEntity(); TradeLicenseEntity actualResult = tradeLicenseJdbcRepository.create(tradeLicenseEntity); List<Map<String, Object>> result = namedParameterJdbcTemplate.query("SELECT * FROM egtl_license", new TradeLicenseResultExtractor()); Map<String, Object> row = result.get(0); assertThat(row.get("tenantId")).isEqualTo(actualResult.getTenantId()); assertThat(row.get("active")).isEqualTo(actualResult.getActive()); assertThat(row.get("oldLicenseNumber")).isEqualTo(actualResult.getOldLicenseNumber()); }
|
### Question:
CorrelationIdFilter extends ZuulFilter { @Override public Object run() { RequestContext ctx = RequestContext.getCurrentContext(); final String correlationId = UUID.randomUUID().toString(); MDC.put(CORRELATION_ID_KEY, correlationId); ctx.set(CORRELATION_ID_KEY, correlationId); logger.debug(RECEIVED_REQUEST_MESSAGE, ctx.getRequest().getRequestURI()); return null; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_set_context_with_correlation_id() { MockHttpServletRequest request = new MockHttpServletRequest(); RequestContext.getCurrentContext().setRequest(request); correlationIdFilter.run(); assertNotNull(RequestContext.getCurrentContext().get("CORRELATION_ID")); }
@Test public void test_should_set_mdc_with_correlation_id() { MockHttpServletRequest request = new MockHttpServletRequest(); RequestContext.getCurrentContext().setRequest(request); correlationIdFilter.run(); assertNotNull(MDC.get("CORRELATION_ID")); }
|
### Question:
CorrelationIdFilter extends ZuulFilter { @Override public int filterOrder() { return 0; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_set_filter_order_to_beginning() { assertEquals(0, correlationIdFilter.filterOrder()); }
|
### Question:
CorrelationIdFilter extends ZuulFilter { @Override public String filterType() { return "pre"; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_execute_as_pre_filter() { assertEquals("pre", correlationIdFilter.filterType()); }
|
### Question:
CorrelationIdFilter extends ZuulFilter { @Override public boolean shouldFilter() { return true; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_always_execute_filter() { assertTrue( correlationIdFilter.shouldFilter()); }
|
### Question:
ResponseEnhancementFilter extends ZuulFilter { @Override public Object run() { RequestContext ctx = RequestContext.getCurrentContext(); ctx.addZuulResponseHeader(CORRELATION_HEADER_NAME, getCorrelationId()); return null; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_set_correlation_id_response_header() { RequestContext.getCurrentContext().set("CORRELATION_ID", "someCorrelationId"); final MockHttpServletResponse response = new MockHttpServletResponse(); response.setStatus(400); RequestContext.getCurrentContext().setResponse(response); final MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("http: RequestContext.getCurrentContext().setRequest(request); filter.run(); final List<Pair<String, String>> zuulResponseHeaders = RequestContext.getCurrentContext().getZuulResponseHeaders(); assertEquals(1, zuulResponseHeaders.size()); final Pair<String, String> stringPair = zuulResponseHeaders.get(0); assertEquals("x-correlation-id", stringPair.first()); assertEquals("someCorrelationId", stringPair.second()); }
|
### Question:
ResponseEnhancementFilter extends ZuulFilter { @Override public boolean shouldFilter() { return true; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_always_execute_filter() { assertTrue( filter.shouldFilter()); }
|
### Question:
ResponseEnhancementFilter extends ZuulFilter { @Override public int filterOrder() { return 0; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void test_should_execute_as_last_post_filter() { assertEquals(0, filter.filterOrder()); }
|
### Question:
CustomRequestWrapper extends HttpServletRequestWrapper { @Override public ServletInputStream getInputStream() { return new ServletInputStreamWrapper(payload.getBytes()); } CustomRequestWrapper(HttpServletRequest request); String getPayload(); void setPayload(String payload); @Override int getContentLength(); @Override long getContentLengthLong(); @Override ServletInputStream getInputStream(); }### Answer:
@Test public void test_should_allow_play_load_to_be_retrieved_multiple_times() throws IOException { final MockHttpServletRequest request = new MockHttpServletRequest(); final String expectedContent = "foobar"; request.setContent(IOUtils.toByteArray(new StringReader(expectedContent))); final CustomRequestWrapper wrapper = new CustomRequestWrapper(request); assertEquals(expectedContent, new String(IOUtils.toByteArray(wrapper.getInputStream()))); assertEquals(expectedContent, new String(IOUtils.toByteArray(wrapper.getInputStream()))); }
|
### Question:
TokenRepository { public Token save(Token token) { final Map<String, Object> tokenInputs = new HashMap<String, Object>(); Date createdDate = new Date(); tokenInputs.put("id", token.getUuid()); tokenInputs.put("tenantId", token.getTenantId()); tokenInputs.put("tokenNumber", token.getNumber()); tokenInputs.put("tokenIdentity", token.getIdentity()); tokenInputs.put("validated", NO); tokenInputs.put("ttlSecs", token.getTimeToLiveInSeconds()); tokenInputs.put("createdDate", createdDate); tokenInputs.put("createdBy", 0l); tokenInputs.put("version", 0l); tokenInputs.put("createddatenew", System.currentTimeMillis()); namedParameterJdbcTemplate.update(INSERT_TOKEN, tokenInputs); return token; } TokenRepository(NamedParameterJdbcTemplate namedParameterJdbcTemplate); Token save(Token token); Token markAsValidated(Token token); Tokens findByNumberAndIdentityAndTenantId(ValidateRequest request); Tokens findByNumberAndIdentityAndTenantIdLike(ValidateRequest request); Token findBy(TokenSearchCriteria searchCriteria); }### Answer:
@Test public void test_should_save_entity_token() { final Token token = Token.builder().uuid(UUID.randomUUID().toString()).number("99999").identity("someIdentity") .timeToLiveInSeconds(400l).createdDate(new Date()).tenantId("test").build(); Token savedToken = tokenRepository.save(token); assertNotNull(savedToken); assertEquals(token.getTenantId(), savedToken.getTenantId()); assertEquals(token.getUuid(), savedToken.getUuid()); }
|
### Question:
TokenRepository { public Tokens findByNumberAndIdentityAndTenantId(ValidateRequest request) { final Map<String, Object> tokenInputs = new HashMap<String, Object>(); tokenInputs.put("tokenNumber", request.getOtp()); tokenInputs.put("tokenIdentity", request.getIdentity()); tokenInputs.put("tenantId", request.getTenantId()); List<Token> domainTokens = namedParameterJdbcTemplate.query(GETTOKENS_BY_NUMBER_IDENTITY_TENANT, tokenInputs, new TokenRowMapper()); return new Tokens(domainTokens); } TokenRepository(NamedParameterJdbcTemplate namedParameterJdbcTemplate); Token save(Token token); Token markAsValidated(Token token); Tokens findByNumberAndIdentityAndTenantId(ValidateRequest request); Tokens findByNumberAndIdentityAndTenantIdLike(ValidateRequest request); Token findBy(TokenSearchCriteria searchCriteria); }### Answer:
@Test @Sql(scripts = { "/sql/clearTokens.sql", "/sql/createTokens.sql" }) public void test_should_retrieve_otp_for_given_token_number_and_identity() { ValidateRequest validateRequest = ValidateRequest.builder().otp("token2").identity("identity2") .tenantId("tenant2").build(); final Tokens actualTokens = tokenRepository.findByNumberAndIdentityAndTenantId(validateRequest); assertNotNull(actualTokens); final Token firstToken = actualTokens.getTokens().get(0); assertEquals("id2", firstToken.getUuid()); assertEquals("identity2", firstToken.getIdentity()); assertEquals("tenant2", firstToken.getTenantId()); assertEquals("token2", firstToken.getNumber()); assertEquals(Long.valueOf(200), firstToken.getTimeToLiveInSeconds()); assertFalse(firstToken.isValidated()); assertNotNull(firstToken.getCreatedDate()); }
|
### Question:
TokenRepository { public Token findBy(TokenSearchCriteria searchCriteria) { Token token = null; final Map<String, Object> tokenInputs = new HashMap<String, Object>(); tokenInputs.put("id", searchCriteria.getUuid()); List<Token> domainTokens = namedParameterJdbcTemplate.query(GETTOKEN_BYID, tokenInputs, new TokenRowMapper()); if (domainTokens != null && !domainTokens.isEmpty()) { token = domainTokens.get(0); } return token; } TokenRepository(NamedParameterJdbcTemplate namedParameterJdbcTemplate); Token save(Token token); Token markAsValidated(Token token); Tokens findByNumberAndIdentityAndTenantId(ValidateRequest request); Tokens findByNumberAndIdentityAndTenantIdLike(ValidateRequest request); Token findBy(TokenSearchCriteria searchCriteria); }### Answer:
@Test @Sql(scripts = { "/sql/clearTokens.sql", "/sql/createTokens.sql" }) public void test_should_fetch_token_by_id() { TokenSearchCriteria searchCriteria = new TokenSearchCriteria("id1", "tenant1"); final Token token = tokenRepository.findBy(searchCriteria); assertTrue(token.isValidated()); }
@Test @Sql(scripts = { "/sql/clearTokens.sql", "/sql/createTokens.sql" }) public void test_should_return_null_when_token_not_present_for_given_id() { TokenSearchCriteria searchCriteria = new TokenSearchCriteria("id5", "tenant6"); final Token token = tokenRepository.findBy(searchCriteria); assertNull(token); }
|
### Question:
TokenRepository { public Token markAsValidated(Token token) { token.setValidated(true); final boolean isUpdateSuccessful = markTokenAsValidated(token.getUuid()) == UPDATED_ROWS_COUNT; if (!isUpdateSuccessful) { throw new TokenUpdateException(token); } return token; } TokenRepository(NamedParameterJdbcTemplate namedParameterJdbcTemplate); Token save(Token token); Token markAsValidated(Token token); Tokens findByNumberAndIdentityAndTenantId(ValidateRequest request); Tokens findByNumberAndIdentityAndTenantIdLike(ValidateRequest request); Token findBy(TokenSearchCriteria searchCriteria); }### Answer:
@Test @Sql(scripts = { "/sql/clearTokens.sql", "/sql/createTokens.sql" }) public void test_should_return_true_when_token_is_updated_to_validated() { final Token token = Token.builder().uuid("id1").build(); tokenRepository.markAsValidated(token); assertTrue(token.isValidated()); }
@Test(expected = TokenUpdateException.class) public void test_should_return_false_when_token_is_not_updated_successfully() { final Token token = Token.builder().uuid("uuid").build(); tokenRepository.markAsValidated(token); }
|
### Question:
OtpController { @PostMapping("v1/_search") public OtpResponse search(@RequestBody OtpRequest request) { final Token token = tokenService.search(request.toSearchCriteria()); return new OtpResponse(token); } OtpController(TokenService tokenService); @PostMapping("v1/_create") @ResponseStatus(HttpStatus.CREATED) OtpResponse createOtp(@RequestBody OtpRequest otpRequest); @PostMapping("v1/_validate") OtpResponse validateOtp(@RequestBody OtpValidateRequest request); @PostMapping("v1/_search") OtpResponse search(@RequestBody OtpRequest request); }### Answer:
@Test public void test_should_return_token_for_given_search_criteria() throws Exception { final Token token = Token.builder() .uuid("uuid") .identity(IDENTITY) .tenantId(TENANT_ID) .number("randomNumber") .build(); final String uuid = "uuid"; when(tokenService.search(new TokenSearchCriteria(uuid, TENANT_ID))).thenReturn(token); mockMvc.perform(post("/v1/_search").contentType(MediaType.APPLICATION_JSON_UTF8) .content(resources.getFileContents("otpSearchRequest.json"))) .andExpect(status().isOk()) .andExpect(content().json(resources.getFileContents("createOtpResponse.json"))); }
@Test public void test_should_return_error_response_when_search_is_not_valid() throws Exception { final TokenSearchCriteria searchCriteria = new TokenSearchCriteria("", ""); final InvalidTokenSearchCriteriaException exception = new InvalidTokenSearchCriteriaException(searchCriteria); when(tokenService.search(searchCriteria)).thenThrow(exception); mockMvc.perform(post("/v1/_search").contentType(MediaType.APPLICATION_JSON_UTF8) .content(resources.getFileContents("invalidOtpSearchRequest.json"))) .andExpect(status().isBadRequest()) .andExpect(content().json(resources.getFileContents("invalidOtpSearchResponse.json"))); }
|
### Question:
TokenSearchCriteria { public void validate() { if(isIdAbsent() || isTenantIdAbsent()) { throw new InvalidTokenSearchCriteriaException(this); } } void validate(); boolean isIdAbsent(); boolean isTenantIdAbsent(); }### Answer:
@Test public void test_should_not_throw_exception_when_search_criteria_has_mandatory_fields() { final TokenSearchCriteria searchCriteria = new TokenSearchCriteria("uuid", "tenant"); searchCriteria.validate(); }
|
### Question:
ValidateRequest { public void validate() { if (isTenantIdAbsent() || isOtpAbsent() || isIdentityAbsent()) { throw new InvalidTokenValidateRequestException(this); } } void validate(); boolean isIdentityAbsent(); boolean isOtpAbsent(); boolean isTenantIdAbsent(); }### Answer:
@Test public void test_should_not_throw_validation_exception_when_request_has_mandatory_parameters() { final ValidateRequest validateRequest = ValidateRequest.builder() .otp("otp") .tenantId("tenant") .identity("identity") .build(); validateRequest.validate(); }
|
### Question:
Tokens { public boolean hasSingleNonExpiredToken(LocalDateTime now) { return !CollectionUtils.isEmpty(tokens) && tokens.stream().anyMatch(token -> !token.isExpired(now)); } boolean hasSingleNonExpiredToken(LocalDateTime now); Token getNonExpiredToken(LocalDateTime now); }### Answer:
@Test public void test_should_return_false_when_matching_tokens_is_null() { final Tokens tokens = new Tokens(null); final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC")); assertFalse(tokens.hasSingleNonExpiredToken(now)); }
@Test public void test_should_return_false_when_all_tokens_are_expired() { final Token token1 = mock(Token.class); final LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC")); when(token1.isExpired(now)).thenReturn(true); final Token token2 = mock(Token.class); when(token2.isExpired(now)).thenReturn(true); final Tokens tokens = new Tokens(Arrays.asList(token1, token2)); assertFalse(tokens.hasSingleNonExpiredToken(now)); }
|
### Question:
Token { public boolean isExpired(LocalDateTime now) { return now.isAfter(expiryDateTime); } boolean isExpired(LocalDateTime now); }### Answer:
@Test public void test_is_expired_should_return_false_when_token_expiry_is_in_the_future() { final LocalDateTime now = LocalDateTime.now(ZoneId.of(IST)); final Token token = Token.builder() .expiryDateTime(now.plusSeconds(30)) .build(); assertFalse(token.isExpired(now)); }
@Test public void test_is_expired_should_return_false_when_token_expiry_is_now() { final LocalDateTime now = LocalDateTime.now(ZoneId.of(IST)); final Token token = Token.builder() .expiryDateTime(now) .build(); assertFalse(token.isExpired(now)); }
@Test public void test_is_expired_should_return_true_when_token_expiry_is_in_the_past() { final LocalDateTime now = LocalDateTime.now(ZoneId.of(IST)); final Token token = Token.builder() .expiryDateTime(now.minusSeconds(30)) .build(); assertTrue(token.isExpired(now)); }
|
### Question:
TokenRequest { public void validate() { if (isIdentityAbsent() || isTenantIdAbsent()) { throw new InvalidTokenRequestException(this); } } long getTimeToLive(); void validate(); boolean isTenantIdAbsent(); boolean isIdentityAbsent(); String generateToken(); }### Answer:
@Test public void test_should_not_throw_validation_exception_when_mandatory_fields_are_present() { final TokenRequest token = new TokenRequest("identity","tenant"); token.validate(); }
|
### Question:
TokenRequest { public String generateToken() { return randomNumeric(5); } long getTimeToLive(); void validate(); boolean isTenantIdAbsent(); boolean isIdentityAbsent(); String generateToken(); }### Answer:
@Test public void test_should_generate_5_digit_token() { final TokenRequest token = new TokenRequest("identity","tenant"); assertNotNull(token.generateToken()); assertEquals(5, token.generateToken().length()); }
|
### Question:
TokenRequest { public long getTimeToLive() { return TTL_IN_SECONDS; } long getTimeToLive(); void validate(); boolean isTenantIdAbsent(); boolean isIdentityAbsent(); String generateToken(); }### Answer:
@Test public void test_should_300_second_ttl() { final TokenRequest token = new TokenRequest("identity","tenant"); assertEquals(300, token.getTimeToLive()); }
|
### Question:
TokenService { public Token create(TokenRequest tokenRequest) { tokenRequest.validate(); Token token = Token.builder().uuid(UUID.randomUUID().toString()).tenantId(tokenRequest.getTenantId()) .identity(tokenRequest.getIdentity()).number(randomNumeric(otpLength)) .timeToLiveInSeconds(tokenRequest.getTimeToLive()).build(); return tokenRepository.save(token); } @Autowired TokenService(TokenRepository tokenRepository); Token create(TokenRequest tokenRequest); Token validate(ValidateRequest validateRequest); Token search(TokenSearchCriteria searchCriteria); }### Answer:
@Test public void test_should_save_new_token_with_given_identity_and_tenant() { final Token savedToken = Token.builder().build(); final TokenRequest tokenRequest = mock(TokenRequest.class); when(tokenRepository.save(any(Token.class))).thenReturn(savedToken); final Token actualToken = tokenService.create(tokenRequest); assertEquals(savedToken, actualToken); }
|
### Question:
ApplicationNumberGeneratorServiceImpl implements ApplicationNumberGeneratorService { public String generate(final String tenantId, final RequestInfo requestInfo) { return idGenService.generate(tenantId, propertiesManager.getIdApplicationNumberGenNameServiceTopic(), propertiesManager.getIdApplicationNumberGenFormatServiceTopic(), requestInfo); } String generate(final String tenantId, final RequestInfo requestInfo); }### Answer:
@Test public void test_tl_number_generator_should_return_number() { final String applicationNumber = applicationNumberGeneratorService.generate("ap.kurnool", new RequestInfo()); assertEquals("12345", applicationNumber); }
|
### Question:
TokenService { public Token search(TokenSearchCriteria searchCriteria) { return tokenRepository.findBy(searchCriteria); } @Autowired TokenService(TokenRepository tokenRepository); Token create(TokenRequest tokenRequest); Token validate(ValidateRequest validateRequest); Token search(TokenSearchCriteria searchCriteria); }### Answer:
@Test public void test_should_return_otp_for_given_search_criteria() { final Token expectedToken = Token.builder().build(); final TokenSearchCriteria searchCriteria = new TokenSearchCriteria("uuid", "tenant"); when(tokenRepository.findBy(searchCriteria)).thenReturn(expectedToken); final Token actualToken = tokenService.search(searchCriteria); assertEquals(expectedToken, actualToken); }
|
### Question:
EmailNotificationListener { @KafkaListener(topics = "${kafka.topics.notification.mail.name}") public void listen(EmailRequest emailRequest) { emailService.sendEmail(emailRequest.toDomain()); } EmailNotificationListener(EmailService emailService); @KafkaListener(topics = "${kafka.topics.notification.mail.name}") void listen(EmailRequest emailRequest); }### Answer:
@Test public void test_should_send_email() throws Exception { EmailNotificationListener emailNotificationListener = new EmailNotificationListener(emailService); EmailRequest emailRequest = EmailRequest.builder() .isHTML(true) .email("email") .subject("subject") .body("body") .build(); emailNotificationListener.listen(emailRequest); final Email expectedEmail = Email.builder() .subject("subject") .body("body") .toAddress("email") .html(true) .build(); verify(emailService).sendEmail(expectedEmail); }
|
### Question:
EmailRequest { public Email toDomain() { return Email.builder() .toAddress(email) .subject(subject) .body(body) .html(isHTML) .build(); } Email toDomain(); }### Answer:
@Test public void to_domain_should_return_domain_object() throws Exception { EmailRequest emailRequest = EmailRequest.builder() .email("[email protected]") .body("body") .subject("subject") .isHTML(true) .build(); Email email = emailRequest.toDomain(); assertThat(email.getToAddress()).isEqualTo("[email protected]"); assertThat(email.getSubject()).isEqualTo("subject"); assertThat(email.getBody()).isEqualTo("body"); assertThat(email.isHtml()).isTrue(); }
|
### Question:
DiskFileStoreRepository { public List<Artifact> write(List<org.egov.filestore.domain.model.Artifact> artifacts) { List<org.egov.filestore.persistence.entity.Artifact> persistList = new ArrayList<>(); artifacts.forEach(artifact -> { MultipartFile multipartFile = artifact.getMultipartFile(); FileLocation fileLocation = artifact.getFileLocation(); if (isS3Enabled) { s3Repository.writeToS3(multipartFile, fileLocation); fileLocation.setFileSource(AwsS3Source); } else { Path path = getPath(fileLocation); fileRepository.write(multipartFile, path); fileLocation.setFileSource(diskFileStorage); } persistList.add(mapToEntity(artifact)); }); return persistList; } DiskFileStoreRepository(FileRepository fileRepository,
@Value("${file.storage.mount.path}") String fileMountPath); List<Artifact> write(List<org.egov.filestore.domain.model.Artifact> artifacts); Resource read(FileLocation fileLocation); }### Answer:
@Test public void shouldStoreFileToDisk() throws Exception { MultipartFile file1 = mock(MultipartFile.class); MultipartFile file2 = mock(MultipartFile.class); String fileStoreId2 = UUID.randomUUID().toString(); String fileStoreId1 = UUID.randomUUID().toString(); List<Artifact> listOfMockedArtifacts = Arrays.asList( new Artifact(file1, new FileLocation(fileStoreId1, MODULE, TAG, TENANT_ID,FILENAME,FILE_SOURCE)), new Artifact(file2, new FileLocation(fileStoreId2, MODULE, TAG, TENANT_ID,FILENAME,FILE_SOURCE)) ); diskFileStoreRepository.write(listOfMockedArtifacts); verify(fileRepository).write(file1, Paths.get(FILE_STORAGE_MOUNT_PATH, FILENAME)); verify(fileRepository).write(file2, Paths.get(FILE_STORAGE_MOUNT_PATH, FILENAME)); }
|
### Question:
DiskFileStoreRepository { public Resource read(FileLocation fileLocation) { Resource resource = null; if(fileLocation.getFileSource()==null || fileLocation.getFileSource().equals(diskFileStorage)) { Path path = getPath(fileLocation); resource = fileRepository.read(path); if(resource == null) resource = fileRepository.read(getPathOldVersion(fileLocation)); }else if(fileLocation.getFileSource().equals(AwsS3Source)){ resource = s3Repository.getObject(fileLocation.getFileName()); } return resource; } DiskFileStoreRepository(FileRepository fileRepository,
@Value("${file.storage.mount.path}") String fileMountPath); List<Artifact> write(List<org.egov.filestore.domain.model.Artifact> artifacts); Resource read(FileLocation fileLocation); }### Answer:
@Test public void shouldReturnResourceForGivenPath() { FileLocation fileLocation = new FileLocation("fileStoreId", MODULE, TAG, TENANT_ID,FILENAME,FILE_SOURCE); Resource expectedResource = mock(Resource.class); when(fileRepository.read(Paths.get(FILE_STORAGE_MOUNT_PATH, FILENAME))) .thenReturn(expectedResource); Resource actualResource = diskFileStoreRepository.read(fileLocation); assertEquals(expectedResource, actualResource); }
|
### Question:
ArtifactRepository { public List<String> save(List<org.egov.filestore.domain.model.Artifact> artifacts) { cloudFilesManager.saveFiles(artifacts); List<Artifact> artifactEntities = new ArrayList<>(); artifacts.forEach(artifact -> { artifactEntities.add(mapToEntity(artifact)); }); return fileStoreJpaRepository.save(artifactEntities).stream() .map(Artifact::getFileStoreId) .collect(Collectors.toList()); } ArtifactRepository(DiskFileStoreRepository diskFileStoreRepository,
FileStoreJpaRepository fileStoreJpaRepository); List<String> save(List<org.egov.filestore.domain.model.Artifact> artifacts); Resource find(String fileStoreId, String tenantId); List<FileInfo> findByTag(String tag, String tenantId); List<Artifact> getByTenantIdAndFileStoreIdList(String tenantId, List<String> fileStoreIds); }### Answer:
@Ignore @Test public void shouldSaveArtifactToRepository() throws Exception { List<org.egov.filestore.domain.model.Artifact> listOfMockedArtifacts = getListOfArtifacts(); artifactRepository.save(listOfMockedArtifacts); verify(diskFileStoreRepository).write(listOfMockedArtifacts); }
|
### Question:
ArtifactRepository { public Resource find(String fileStoreId, String tenantId) throws IOException { Artifact artifact = fileStoreJpaRepository.findByFileStoreIdAndTenantId(fileStoreId, tenantId); if (artifact == null) throw new ArtifactNotFoundException(fileStoreId); org.springframework.core.io.Resource resource = diskFileStoreRepository.read(artifact.getFileLocation()); return new Resource(artifact.getContentType(), artifact.getFileName(), resource, artifact.getTenantId(),""+resource.getFile().length()+" bytes"); } ArtifactRepository(DiskFileStoreRepository diskFileStoreRepository,
FileStoreJpaRepository fileStoreJpaRepository); List<String> save(List<org.egov.filestore.domain.model.Artifact> artifacts); Resource find(String fileStoreId, String tenantId); List<FileInfo> findByTag(String tag, String tenantId); List<Artifact> getByTenantIdAndFileStoreIdList(String tenantId, List<String> fileStoreIds); }### Answer:
@Test(expected = ArtifactNotFoundException.class) public void shouldRaiseExceptionWhenArtifactNotFound() throws Exception { when(fileStoreJpaRepository.findByFileStoreIdAndTenantId("fileStoreId", TENANT_ID)).thenReturn(null); artifactRepository.find("fileStoreId", TENANT_ID); }
|
### Question:
ArtifactRepository { public List<FileInfo> findByTag(String tag, String tenantId) { return fileStoreJpaRepository.findByTagAndTenantId(tag, tenantId).stream().map(this::mapArtifactToFileInfo) .collect(Collectors.toList()); } ArtifactRepository(DiskFileStoreRepository diskFileStoreRepository,
FileStoreJpaRepository fileStoreJpaRepository); List<String> save(List<org.egov.filestore.domain.model.Artifact> artifacts); Resource find(String fileStoreId, String tenantId); List<FileInfo> findByTag(String tag, String tenantId); List<Artifact> getByTenantIdAndFileStoreIdList(String tenantId, List<String> fileStoreIds); }### Answer:
@Test public void shouldRetrieveArtifactMetaDataForGivenTag() { when(fileStoreJpaRepository.findByTagAndTenantId(TAG, TENANT_ID)).thenReturn(getListOfArtifactEntities()); List<FileInfo> actual = artifactRepository.findByTag(TAG, TENANT_ID); assertEquals(actual.get(0).getContentType(), "contentType1"); assertEquals(actual.get(0).getTenantId(), TENANT_ID); assertEquals(actual.get(0).getFileLocation().getFileStoreId(), FILE_STORE_ID_1); assertEquals(actual.get(1).getContentType(), "contentType2"); assertEquals(actual.get(1).getTenantId(), TENANT_ID); assertEquals(actual.get(1).getFileLocation().getFileStoreId(), FILE_STORE_ID_2); verify(fileStoreJpaRepository).findByTagAndTenantId(TAG, TENANT_ID); }
|
### Question:
TradeLicenseNumberGeneratorServiceImpl implements TradeLicenseNumberGeneratorService { public String generate(final String tenantId, final RequestInfo requestInfo) { return idGenService.generate(tenantId, propertiesManager.getIdTLNumberGenNameServiceTopic(), propertiesManager.getIdTLNumberGenFormatServiceTopic(), requestInfo); } String generate(final String tenantId, final RequestInfo requestInfo); }### Answer:
@Test public void test_tl_number_generator_should_return_number() { final String tlNumber = tradeLicenseNumberGeneratorService.generate("ap.kurnool", new RequestInfo()); assertEquals("TL/00001/2017", tlNumber); }
|
### Question:
ResponseFactory { public GetFilesByTagResponse getFilesByTagResponse(List<FileInfo> listOfFileInfo) { List<FileRecord> fileRecords = listOfFileInfo.stream().map(fileInfo -> { String url = String.format(FORMAT, contextPath, fileInfo.getFileLocation().getFileStoreId(), fileInfo.getTenantId()); return new FileRecord(url, fileInfo.getContentType()); }).collect(Collectors.toList()); return new GetFilesByTagResponse(fileRecords); } ResponseFactory(@Value("${server.contextPath}") String contextPath); GetFilesByTagResponse getFilesByTagResponse(List<FileInfo> listOfFileInfo); }### Answer:
@Test public void test_getFilesByTagResponse_from_FileInfo() throws Exception { FileLocation fileLocation1 = new FileLocation(FILE_STORE_ID_1, MODULE, TAG, TENANT_ID,FILENAME,FILE_SOURCE); FileLocation fileLocation2 = new FileLocation(FILE_STORE_ID_2, MODULE, TAG, TENANT_ID,FILENAME,FILE_SOURCE); FileInfo fileInfo1 = new FileInfo(CONTENT_TYPE_1, fileLocation1, TENANT_ID); FileInfo fileInfo2 = new FileInfo(CONTENT_TYPE_2, fileLocation2, TENANT_ID); List<FileInfo> listOfFileInfo = asList(fileInfo1, fileInfo2); GetFilesByTagResponse result = responseFactory.getFilesByTagResponse(listOfFileInfo); assertThat(result.getFiles().get(0).getContentType()).isEqualTo(CONTENT_TYPE_1); assertThat(result.getFiles().get(0).getUrl()).isEqualTo ("/fileStore/v1/files/id?fileStoreId=FileStoreID1&tenantId=default"); assertThat(result.getFiles().get(1).getContentType()).isEqualTo(CONTENT_TYPE_2); assertThat(result.getFiles().get(1).getUrl()).isEqualTo ("/fileStore/v1/files/id?fileStoreId=FileStoreID2&tenantId=default"); }
|
### Question:
IdGeneratorService { public String getId() { return UUID.randomUUID().toString(); } String getId(); }### Answer:
@Test public void shouldGenerateId() throws Exception { IdGeneratorService idGeneratorService = new IdGeneratorService(); assertEquals(36, idGeneratorService.getId().length()); }
|
### Question:
StorageService { public List<String> save(List<MultipartFile> filesToStore, String module, String tag, String tenantId) { validateFilesToUpload(filesToStore, module, tag, tenantId); log.info(UPLOAD_MESSAGE, module, tag, filesToStore.size()); List<Artifact> artifacts = mapFilesToArtifacts(filesToStore, module, tag, tenantId); return this.artifactRepository.save(artifacts); } @Autowired StorageService(ArtifactRepository artifactRepository, IdGeneratorService idGeneratorService); List<String> save(List<MultipartFile> filesToStore, String module, String tag, String tenantId); Resource retrieve(String fileStoreId, String tenantId); List<FileInfo> retrieveByTag(String tag, String tenantId); Map<String, String> getUrls(String tenantId, List<String> fileStoreIds); }### Answer:
@Test public void shouldSaveArtifacts() throws Exception { List<MultipartFile> listOfMultipartFiles = getMockFileList(); List<Artifact> listOfArtifacts = getArtifactList(listOfMultipartFiles); when(idGeneratorService.getId()).thenReturn(FILE_STORE_ID_1, FILE_STORE_ID_2); storageService.save(listOfMultipartFiles, MODULE, TAG,TENANTID); verify(artifactRepository).save(argThat(new ArtifactMatcher(listOfArtifacts))); }
@Test(expected = EmptyFileUploadRequestException.class) public void test_should_throw_exception_when_list_of_files_to_save_is_empty() { storageService.save(Collections.emptyList(), MODULE, TAG, TENANTID); }
|
### Question:
StorageService { public Resource retrieve(String fileStoreId, String tenantId) throws IOException { return artifactRepository.find(fileStoreId, tenantId); } @Autowired StorageService(ArtifactRepository artifactRepository, IdGeneratorService idGeneratorService); List<String> save(List<MultipartFile> filesToStore, String module, String tag, String tenantId); Resource retrieve(String fileStoreId, String tenantId); List<FileInfo> retrieveByTag(String tag, String tenantId); Map<String, String> getUrls(String tenantId, List<String> fileStoreIds); }### Answer:
@Test public void shouldRetrieveArtifact() throws Exception { Resource expectedResource = mock(Resource.class); when(artifactRepository.find("fileStoreId",TENANTID)).thenReturn(expectedResource); Resource actualResource = storageService.retrieve("fileStoreId",TENANTID); assertEquals(expectedResource, actualResource); }
|
### Question:
StorageService { public List<FileInfo> retrieveByTag(String tag, String tenantId) { return artifactRepository.findByTag(tag, tenantId); } @Autowired StorageService(ArtifactRepository artifactRepository, IdGeneratorService idGeneratorService); List<String> save(List<MultipartFile> filesToStore, String module, String tag, String tenantId); Resource retrieve(String fileStoreId, String tenantId); List<FileInfo> retrieveByTag(String tag, String tenantId); Map<String, String> getUrls(String tenantId, List<String> fileStoreIds); }### Answer:
@Test public void shouldRetrieveListOfUrlsGivenATag() throws Exception { List<FileInfo> listOfFileInfo = getListOfFileInfo(); when(artifactRepository.findByTag(TAG,TENANTID)).thenReturn(listOfFileInfo); List<FileInfo> actual = storageService.retrieveByTag(TAG,TENANTID); assertEquals(listOfFileInfo, actual); }
|
### Question:
TransactionService { public List<Transaction> getTransactions(TransactionCriteria transactionCriteria) { log.info(transactionCriteria.toString()); try { return transactionRepository.fetchTransactions(transactionCriteria); } catch (DataAccessException e) { log.error("Unable to fetch data from the database for criteria: " + transactionCriteria.toString(), e); throw new CustomException("FETCH_TXNS_FAILED", "Unable to fetch transactions from store"); } } @Autowired TransactionService(TransactionValidator validator, GatewayService gatewayService, Producer producer,
TransactionRepository
transactionRepository, CollectionService collectionService,
EnrichmentService enrichmentService,
AppProperties appProperties); Transaction initiateTransaction(TransactionRequest transactionRequest); List<Transaction> getTransactions(TransactionCriteria transactionCriteria); List<Transaction> updateTransaction(RequestInfo requestInfo, Map<String, String> requestParams); }### Answer:
@Test public void getTransactionsSuccessTest(){ Transaction txn = Transaction.builder().txnId("PT_001") .txnAmount("100") .tenantId("pb") .billId("ORDER0012") .productInfo("Property Tax Payment") .gateway("ABCD123") .build(); TransactionCriteria criteria = TransactionCriteria.builder().tenantId("pb").txnId("PT_001").build(); when(transactionRepository.fetchTransactions(criteria)).thenReturn(Collections.singletonList(txn)); assertEquals(1, transactionService.getTransactions(criteria).size()); when(transactionRepository.fetchTransactions(criteria)).thenReturn(Collections.emptyList()); assertEquals(0, transactionService.getTransactions(criteria).size()); }
@Test(expected = CustomException.class) public void getTransactionsFailTest(){ TransactionCriteria criteria = TransactionCriteria.builder().tenantId("pb").txnId("PT_001").build(); when(transactionRepository.fetchTransactions(criteria)).thenThrow(new TransientDataAccessResourceException("test")); transactionService.getTransactions(criteria); }
|
### Question:
LicenseBillService { public DemandResponse createBill(final TradeLicense tradeLicense, final RequestInfo requestInfo, Map<String, Object> demandMap) throws ParseException { List<Demand> demands = prepareBill(tradeLicense, null, requestInfo, demandMap); DemandResponse demandRes = createBill(demands, requestInfo); if (demandRes != null && demandRes.getDemands() != null && !demandRes.getDemands().isEmpty()) tradeLicense.setBillId(demandRes.getDemands().get(0).getId()); return demandRes; } DemandResponse createBill(final TradeLicense tradeLicense, final RequestInfo requestInfo, Map<String, Object> demandMap); DemandResponse updateBill(final TradeLicense tradeLicense, final Long billId, final RequestInfo requestInfo, Map<String, Object> demandMap); }### Answer:
@Test public void test_create_bill() throws ParseException { RequestInfo requestInfo = new RequestInfo(); UserInfo userInfo = new UserInfo(); userInfo.setId(1); requestInfo.setUserInfo(userInfo); TradeLicense license = new TradeLicense(); license.setTenantId("mh.roha"); license.setTradeType(BusinessNature.PERMANENT); LicenseApplication application = new LicenseApplication(); application.setApplicationNumber("1234"); application.setLicenseFee(100D); LicenseFeeDetail feeDetail = new LicenseFeeDetail(); feeDetail.setAmount(100D); application.setFeeDetails(Collections.singletonList(feeDetail)); license.setApplication(application); license.setValidityYears(1L); Map<String, Object> licenseFeeMap = new HashMap<String, Object>(); licenseFeeMap.put("minimumAmountPayable", BigDecimal.valueOf(license.getApplication().getLicenseFee())); licenseFeeMap.put("taxHeadMasterCode", propertiesManager.getTaxHeadMasterCode()); licenseFeeMap.put("taxAmount", new BigDecimal(propertiesManager.getApplicationFeeAmount())); DemandResponse demandResponse = licenseBillService.createBill(license, requestInfo, licenseFeeMap); assertEquals("1", demandResponse.getDemands().get(0).getId()); }
|
### Question:
IdGenRepository { public IdGenerationResponse getId(RequestInfo requestInfo, String tenantId, String name, String format, int count) { List<IdRequest> reqList = new ArrayList<>(); for (int i = 0; i < count; i++) { reqList.add(new IdRequest(name, tenantId, format)); } IdGenerationRequest req = new IdGenerationRequest(requestInfo, reqList); String uri = UriComponentsBuilder .fromHttpUrl(appProperties.getIdGenHost()) .path(appProperties.getIdGenPath()) .build() .toUriString(); try { return restTemplate.postForObject(uri, req, IdGenerationResponse.class); } catch (HttpClientErrorException e) { log.error("ID Gen Service failure ", e); throw new ServiceCallException(e.getResponseBodyAsString()); } catch (Exception e) { log.error("ID Gen Service failure", e); throw new CustomException("IDGEN_SERVICE_ERROR", "Failed to generate ID, unknown error occurred"); } } @Autowired IdGenRepository(RestTemplate restTemplate, AppProperties appProperties); IdGenerationResponse getId(RequestInfo requestInfo, String tenantId, String name, String format, int count); }### Answer:
@Test public void testIdGen() { RequestInfo requestInfo = new RequestInfo("", "", 0L, "", "", "", "", "", "8e88988e-d342-45c2-81d0-487a2a20350e", null); IdGenerationResponse response = idGenRepository.getId(requestInfo, "pb", "pg.txnid", "" + "PB-PG-[cy:yyyy/MM/dd]-[SEQ_EG_PG_TXN]-[d{2}]", 1); System.out.println(response.getIdResponses()); }
|
### Question:
ComplaintStatus extends AbstractPersistable<Long> { public org.egov.workflow.domain.model.ComplaintStatus toDomain() { return new org.egov.workflow.domain.model.ComplaintStatus(id, name, tenantId, code); } org.egov.workflow.domain.model.ComplaintStatus toDomain(); static final String SEQ_COMPLAINTSTATUS; }### Answer:
@Test public void test_should_map_from_entity_to_domain() { ComplaintStatus complaintStatus = new ComplaintStatus(1L, "name","default","0001"); org.egov.workflow.domain.model.ComplaintStatus complaintStatusModel = complaintStatus.toDomain(); assertThat(complaintStatusModel.getId()).isEqualTo(1); assertThat(complaintStatusModel.getName()).isEqualTo("name"); }
|
### Question:
UserRepository { public UserResponse findUserByIdAndTenantId(Long userId,String tenantId) { String url = String.format("%s%s", userHost, userServiceUrl); UserRequest userRequest = UserRequest.builder().requestInfo(new RequestInfo()) .id(Collections.singletonList(userId)).tenantId(tenantId).build(); return restTemplate.postForObject(url, userRequest, UserResponse.class); } UserRepository(RestTemplate restTemplate, @Value("${user.service.url}") final String userHostUrl,
@Value("${egov.services.user_by_id}") final String userServiceUrl); UserResponse findUserByIdAndTenantId(Long userId,String tenantId); }### Answer:
@Test public void findUserById() throws Exception { final RequestInfo requestInfo = RequestInfo.builder().apiId("org.egov.pgr").ver("1.0").msgId("654654") .authToken("cdaaa28a-f88a-429e-a710-b401097a165c").build(); final User user = User.builder().id(67l).tenantId("tenantId").build(); server.expect(once(), requestTo("http: .andExpect(content().string(new Resources().getFileContents("searchUserByIdRequest.json"))) .andRespond(withSuccess(new Resources().getFileContents("searchUserById.json"), MediaType.APPLICATION_JSON_UTF8)); final UserResponse userResponse = userRepository.findUserByIdAndTenantId(67L,"tenantId"); server.verify(); assertEquals(1, userResponse.getUser().size()); }
|
### Question:
BoundaryRepository { public BoundaryResponse fetchBoundaryById(final Long id, final String tenantId) { final BoundaryServiceResponse boudaryServiceResponse = restTemplate.getForObject(url, BoundaryServiceResponse.class, id, tenantId); return boudaryServiceResponse.getBoundary().get(0); } BoundaryRepository(final RestTemplate restTemplate,
@Value("${egov.services.boundary.host}") final String boundaryServiceHost,
@Value("${egov.services.location.boundaries_by_id}") final String url); BoundaryResponse fetchBoundaryById(final Long id, final String tenantId); }### Answer:
@Test public void test_should_get_boundaries_by_id() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.GET)) .andRespond(withSuccess(new Resources().getFileContents("boundaryResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final BoundaryResponse boundaryResponse = boundaryRepository.fetchBoundaryById(1l, "tenantId"); server.verify(); assertEquals(2, boundaryResponse.getId().intValue()); assertEquals("Srinivas Nagar", boundaryResponse.getName()); }
|
### Question:
PositionRepository { public PositionResponse getById(final Long id, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(RequestInfo.builder().build()).build(); final PositionServiceResponse positionServiceResponse = restTemplate.postForObject(positionsByIdUrl, wrapper, PositionServiceResponse.class, id, tenantId); return positionServiceResponse.getPositions().get(0); } PositionRepository(final RestTemplate restTemplate,
@Value("${egov.services.hrmasters.host}") final String eisServiceHostname,
@Value("${egov.services.hr.position_by_id}") final String positionsByIdUrl); PositionResponse getById(final Long id, final String tenantId); }### Answer:
@Test public void test_should_get_positions_by_id() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("positionResponse.json"), MediaType.APPLICATION_JSON_UTF8)); PositionResponse positionResponse = positionRepository.getById(1l,"tenantId"); server.verify(); assertEquals("position1", positionResponse.getName()); assertEquals(1, positionResponse.getId().intValue()); }
|
### Question:
EmployeeRepository { public EmployeeRes getEmployeeForUserIdAndTenantId(final Long userId, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(RequestInfo.builder().build()).build(); return restTemplate.postForObject(employeesByUserIdUrl, wrapper, EmployeeRes.class, userId, tenantId); } @Autowired EmployeeRepository(final RestTemplate restTemplate,
@Value("${egov.services.hremployee.host}") final String hrEmployeeServiceHostname,
@Value("${egov.services.hr.employee_by_userid}") final String hrEmployeesByUserIdUrl,
@Value("${egov.services.hr.employee_by_position}") final String hrEmployeesByPositionIdurl,
@Value("${egov.services.hr_employee_by_role}") final String hrEmployeesByRoleCodeurl); List<Employee> getByRoleCode(final String roleCode, final String tenantId); EmployeeRes getEmployeeForPositionAndTenantId(final Long posId, final LocalDate asOnDate, final String tenantId); EmployeeRes getEmployeeForUserIdAndTenantId(final Long userId, final String tenantId); }### Answer:
@Test public void test_should_get_employees_by_userid() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("employeeResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final EmployeeRes employeeRes = employeeRepository.getEmployeeForUserIdAndTenantId(1l, "tenantId"); server.verify(); assertEquals(1, employeeRes.getEmployees().size()); }
|
### Question:
EmployeeRepository { public EmployeeRes getEmployeeForPositionAndTenantId(final Long posId, final LocalDate asOnDate, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(RequestInfo.builder().apiId("apiId").ver("ver").ts(new Date()).build()).build(); return restTemplate.postForObject(employeesByPositionIdurl, wrapper, EmployeeRes.class, tenantId, posId, asOnDate.toString("dd/MM/yyyy")); } @Autowired EmployeeRepository(final RestTemplate restTemplate,
@Value("${egov.services.hremployee.host}") final String hrEmployeeServiceHostname,
@Value("${egov.services.hr.employee_by_userid}") final String hrEmployeesByUserIdUrl,
@Value("${egov.services.hr.employee_by_position}") final String hrEmployeesByPositionIdurl,
@Value("${egov.services.hr_employee_by_role}") final String hrEmployeesByRoleCodeurl); List<Employee> getByRoleCode(final String roleCode, final String tenantId); EmployeeRes getEmployeeForPositionAndTenantId(final Long posId, final LocalDate asOnDate, final String tenantId); EmployeeRes getEmployeeForUserIdAndTenantId(final Long userId, final String tenantId); }### Answer:
@Test public void test_should_return_employees_by_positionid() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("employeeResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final EmployeeRes employeeRes = employeeRepository.getEmployeeForPositionAndTenantId(1l, new LocalDate(), "tenantId"); server.verify(); assertEquals(1, employeeRes.getEmployees().size()); }
|
### Question:
EmployeeRepository { public List<Employee> getByRoleCode(final String roleCode, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(RequestInfo.builder().build()).build(); final EmployeeRes employeeRes = restTemplate.postForObject(employeesByRoleCodeurl, wrapper, EmployeeRes.class, roleCode, tenantId); return employeeRes.getEmployees(); } @Autowired EmployeeRepository(final RestTemplate restTemplate,
@Value("${egov.services.hremployee.host}") final String hrEmployeeServiceHostname,
@Value("${egov.services.hr.employee_by_userid}") final String hrEmployeesByUserIdUrl,
@Value("${egov.services.hr.employee_by_position}") final String hrEmployeesByPositionIdurl,
@Value("${egov.services.hr_employee_by_role}") final String hrEmployeesByRoleCodeurl); List<Employee> getByRoleCode(final String roleCode, final String tenantId); EmployeeRes getEmployeeForPositionAndTenantId(final Long posId, final LocalDate asOnDate, final String tenantId); EmployeeRes getEmployeeForUserIdAndTenantId(final Long userId, final String tenantId); }### Answer:
@Test public void test_should_return_employees_by_roleCode() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("employeeResponse.json"), MediaType.APPLICATION_JSON_UTF8)); List<Employee> employees = employeeRepository.getByRoleCode("GRO", "tenantId"); server.verify(); assertEquals(1, employees.size()); }
|
### Question:
ComplaintStatusMappingRepository { public List<org.egov.workflow.domain.model.ComplaintStatus> getNextStatuses(Long currentStatusId , List<Long> roles, String tenantId) { return complaintStatusMappingJpaRepository .findByCurrentStatusIdAndRoleInAndTenantIdOrderByOrderNoAsc(currentStatusId, roles,tenantId).stream() .map(ComplaintStatusMapping::getShowStatus) .map(ComplaintStatus::toDomain) .distinct() .collect(Collectors.toList()); } ComplaintStatusMappingRepository(ComplaintStatusMappingJpaRepository complaintStatusMappingJpaRepository); List<org.egov.workflow.domain.model.ComplaintStatus> getNextStatuses(Long currentStatusId
, List<Long> roles, String tenantId); }### Answer:
@Test public void test_should_get_distinct_next_statuses() { Long currentStatusId = 1L; List<Long> roles = asList(1L, 2L); List<ComplaintStatusMapping> complaintStatusMappingEntities = getListOfComplaintStatusMappingEntities(); when( complaintStatusMappingJpaRepository. findByCurrentStatusIdAndRoleInAndTenantIdOrderByOrderNoAsc(currentStatusId, roles,"default") ).thenReturn(complaintStatusMappingEntities); List<org.egov.workflow.domain.model.ComplaintStatus> result = complaintStatusMappingRepository.getNextStatuses(currentStatusId, roles,"default"); assertThat(result.size()).isEqualTo(2); assertThat(result.get(0).getName()).isEqualTo("PROCESSING"); assertThat(result.get(1).getName()).isEqualTo("COMPLETED"); }
|
### Question:
ComplaintStatusRepository { public List<org.egov.workflow.domain.model.ComplaintStatus> findAll() { return complaintStatusJpaRepository.findAll() .stream() .map(ComplaintStatus::toDomain) .collect(Collectors.toList()); } ComplaintStatusRepository(ComplaintStatusJpaRepository complaintStatusJpaRepository); List<org.egov.workflow.domain.model.ComplaintStatus> findAll(); org.egov.workflow.domain.model.ComplaintStatus findByName(String name); org.egov.workflow.domain.model.ComplaintStatus findByCodeAndTenantId(String code, String tenantId); }### Answer:
@Test public void test_should_find_all_statuses() { when(complaintStatusJpaRepository.findAll()).thenReturn(getListOfComplaintStatusEntities()); List<org.egov.workflow.domain.model.ComplaintStatus> all = complaintStatusRepository.findAll(); assertThat(all.size()).isEqualTo(2); assertThat(all.get(0).getId()).isEqualTo(1L); assertThat(all.get(1).getId()).isEqualTo(2L); }
|
### Question:
ComplaintStatusRepository { public org.egov.workflow.domain.model.ComplaintStatus findByName(String name) { return complaintStatusJpaRepository.findByName(name).toDomain(); } ComplaintStatusRepository(ComplaintStatusJpaRepository complaintStatusJpaRepository); List<org.egov.workflow.domain.model.ComplaintStatus> findAll(); org.egov.workflow.domain.model.ComplaintStatus findByName(String name); org.egov.workflow.domain.model.ComplaintStatus findByCodeAndTenantId(String code, String tenantId); }### Answer:
@Test public void test_should_find_status_by_name() { when(complaintStatusJpaRepository.findByName("REJECTED")) .thenReturn(new ComplaintStatus(1L, "REJECTED","default","0001")); org.egov.workflow.domain.model.ComplaintStatus result = complaintStatusRepository.findByName("REJECTED"); assertThat(result.getId()).isEqualTo(1L); assertThat(result.getName()).isEqualTo("REJECTED"); }
|
### Question:
ComplaintStatusRepository { public org.egov.workflow.domain.model.ComplaintStatus findByCodeAndTenantId(String code, String tenantId){ return complaintStatusJpaRepository.findByCodeAndTenantId(code,tenantId).toDomain(); } ComplaintStatusRepository(ComplaintStatusJpaRepository complaintStatusJpaRepository); List<org.egov.workflow.domain.model.ComplaintStatus> findAll(); org.egov.workflow.domain.model.ComplaintStatus findByName(String name); org.egov.workflow.domain.model.ComplaintStatus findByCodeAndTenantId(String code, String tenantId); }### Answer:
@Test public void test_should_status_by_code_and_tenantId(){ when(complaintStatusJpaRepository.findByCodeAndTenantId("REGISTERED","default")) .thenReturn(new ComplaintStatus(1L, "REGISTERED","default","0001")); org.egov.workflow.domain.model.ComplaintStatus status = complaintStatusRepository.findByCodeAndTenantId("REGISTERED","default"); assertThat(status.getId()).isEqualTo(1L); assertThat(status.getName()).isEqualTo("REGISTERED"); }
|
### Question:
PositionHierarchyRepository { public PositionHierarchyResponse getByPositionByComplaintTypeAndFromPosition(final Long fromPosition, final String serviceCode, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(null).build(); return restTemplate.postForObject(positionHierarchyUrl, wrapper, PositionHierarchyResponse.class, fromPosition, serviceCode, tenantId); } PositionHierarchyRepository(final RestTemplate restTemplate,
@Value("${egov.services.pgrmaster.host}") final String hrMastersServiceHostname,
@Value("${egov.services.pgrmaster.positionhierarchy}") final String url); PositionHierarchyResponse getByPositionByComplaintTypeAndFromPosition(final Long fromPosition, final String serviceCode, final String tenantId); }### Answer:
@Test public void test_should_get_positionhierarchies_by_id() { server.expect(once(), requestTo( "http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("positionHierarchyResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final PositionHierarchyResponse positionResponse = positionHierarchyRepository .getByPositionByComplaintTypeAndFromPosition(1l, "complaintTypeCode", "default"); server.verify(); assertEquals(1, positionResponse.getEscalationHierarchies().size()); }
|
### Question:
ComplaintTypeRepository { public ComplaintTypeResponse fetchComplaintTypeByCode(final String code, final String tenantId) { final RequestInfoBody requestInfoBody = new RequestInfoBody(RequestInfo.builder().build()); final HttpEntity<RequestInfoBody> request = new HttpEntity<>(requestInfoBody); return restTemplate.postForObject(url, request, ComplaintTypeServiceResponse.class, code, tenantId).getComplaintTypes().get(0); } ComplaintTypeRepository(final RestTemplate restTemplate,
@Value("${egov.services.pgrrest.host}") final String complaintTypeServiceHost,
@Value("${egov.services.pgr.complainttypes_by_code}") final String url); ComplaintTypeResponse fetchComplaintTypeByCode(final String code, final String tenantId); }### Answer:
@Test public void test_should_get_complainttype_by_code() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("complaintTypeResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final ComplaintTypeResponse complaintResponseExpected = complaintTypeRepository.fetchComplaintTypeByCode("C001","ap.public"); server.verify(); assertEquals(2, complaintResponseExpected.getId().intValue()); assertEquals("C001", complaintResponseExpected.getServiceCode()); }
|
### Question:
KeywordStatusMappingRepository { public List<org.egov.workflow.domain.model.ComplaintStatus> getAllStatusForKeyword(String keyWord, String tenantId){ List<String> statusCodes = keywordStatusMappingJpaRepository.findByKeywordAndTenantId(keyWord,tenantId) .stream() .map(status -> status.getId().getCode()) .collect(Collectors.toList()); return complaintStatusJpaRepository.findByCodeInAndTenantId(statusCodes,tenantId) .stream() .map(ComplaintStatus::toDomain) .collect(Collectors.toList()); } KeywordStatusMappingRepository(KeywordStatusMappingJpaRepository keywordStatusMappingJpaRepository,
ComplaintStatusJpaRepository complaintStatusJpaRepository); List<org.egov.workflow.domain.model.ComplaintStatus> getAllStatusForKeyword(String keyWord, String tenantId); }### Answer:
@Test public void test_for_get_status_for_keyword(){ when(keywordStatusMappingJpaRepository .findByKeywordAndTenantId("Complaint","default")) .thenReturn(getKeyWordStatusMappingEntities()); List<KeywordStatusMapping> statusList = keywordStatusMappingJpaRepository.findByKeywordAndTenantId( "Complaint","default"); when(complaintStatusJpaRepository.findByCodeInAndTenantId(asList("REGISTERED","CLOSED"),"default")) .thenReturn(getServiceStatusList()); List<org.egov.workflow.domain.model.ComplaintStatus> domainStatuses = keywordStatusMappingRepository .getAllStatusForKeyword("Complaint","default"); assertEquals(domainStatuses.size(),2); assertEquals(domainStatuses.get(0).getCode(), "0001"); }
|
### Question:
DepartmentRestRepository { public DepartmentRes getDepartmentById(final Long departmentId, final String tenantId) { RequestInfoWrapper wrapper = RequestInfoWrapper.builder().RequestInfo(RequestInfo.builder().apiId("apiID").ver("ver").ts(new Date()).msgId("msgID").build()).build(); return restTemplate.postForObject(departmentByIdUrl,wrapper,DepartmentRes.class, departmentId, tenantId); } @Autowired DepartmentRestRepository(final RestTemplate restTemplate,
@Value("${egov.services.commonmasters.host}") final String departmentServiceHostname,
@Value("${egov.services.common_masters.department}") final String departmentByIdUrl); DepartmentRes getDepartmentById(final Long departmentId, final String tenantId); }### Answer:
@Test public void test_should_return_department_by_id() { server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("departmentResponse.json"), MediaType.APPLICATION_JSON_UTF8)); final DepartmentRes departmentRes=departmentRestRepository.getDepartmentById(1L,"default"); server.verify(); assertEquals(1, departmentRes.getDepartment().size()); }
|
### Question:
TradeLicenseRepository { public void add(TradeLicenseRequest request, Boolean isNewRecord) { if (request != null && request.getLicenses() != null && request.getLicenses().size() > 0) { if (isNewRecord) { if (request.getLicenses().get(0).getIsLegacy()) { request.getRequestInfo().setAction("legacy-create"); } else { request.getRequestInfo().setAction("new-create"); } } else { if (request.getLicenses().get(0).getIsLegacy()) { request.getRequestInfo().setAction("legacy-update"); } else { request.getRequestInfo().setAction("new-update"); } } } tradeLicenseQueueRepository.add(request); } Long getNextSequence(); Boolean uniqueCheck(String fieldName, TradeLicense tradeLicense); Boolean idExistenceCheck(TradeLicense tradeLicense); void add(TradeLicenseRequest request, Boolean isNewRecord); @Transactional TradeLicense save(TradeLicense tradeLicense); @Transactional TradeLicense update(TradeLicense tradeLicense); TradeLicense findLicense(LicenseSearch domain); @Transactional List<TradeLicense> search(LicenseSearch domain); @Transactional void createLicenseBill(LicenseBill licenseBill); @Transactional void updateTradeLicenseAfterWorkFlowQuery(String consumerCode, String status); Long getLicenseBillId(Long licenseId); Long getApplicationBillId(Long licenseId); }### Answer:
@Test public void testAdd() { Mockito.doNothing().when(tradeLicenseQueueRepository).add(Mockito.any()); TradeLicenseRequest request = new TradeLicenseRequest(); request.setRequestInfo(getRequestInfo()); request.setLicenses(new ArrayList<TradeLicenseContract>()); request.getLicenses().add(getTradeLicenseContract()); tradeLicenseRepository.add(request, true); Mockito.verify(tradeLicenseQueueRepository).add(request); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.