method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
PipeSizeService { public boolean getPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId) { return pipeSizeRepository.checkPipeSizeInmmAndCode(code, sizeInMilimeter, tenantId); } PipeSizeRequest create(final PipeSizeRequest pipeSizeRequest); PipeSizeRequest update(final PipeSizeRequest pipeSizeRequest); List<PipeSize> pushCreateToQueue(final String topic, final String key, final PipeSizeRequest pipeSizeRequest); List<PipeSize> pushUpdateToQueue(final String topic, final String key, final PipeSizeRequest pipeSizeRequest); boolean getPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId); List<PipeSize> getPipeSizes(final PipeSizeGetRequest pipeSizeGetRequest); }### Answer:
@Test public void test_Should_Get_PipeSize() throws Exception { when(pipeSizeRepository.checkPipeSizeInmmAndCode("code", 1.2, "tenantId")).thenReturn(false); final boolean result = pipeSizeService.getPipeSizeInmmAndCode("code", 1.2, "tenantId"); assertTrue(false == result); }
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException_Get_PipeSize() throws Exception { when(pipeSizeRepository.checkPipeSizeInmmAndCode("code", 1.2, "tenantId")).thenThrow(Exception.class); final boolean result = pipeSizeService.getPipeSizeInmmAndCode("code", 1.2, "tenantId"); assertTrue(false == result); }
|
### Question:
IndexerListener { @KafkaListener(topics = "${kafka.topics.egov.index.name}") public void listen(HashMap<String, Object> sevaRequestMap) throws UnsupportedEncodingException { SevaRequest sevaRequest = objectMapper.convertValue(sevaRequestMap, SevaRequest.class); final ServiceRequestDocument document = documentService.enrich(sevaRequest); elasticSearchRepository.index(document); } @Autowired IndexerListener(ElasticSearchRepository elasticSearchRepository,
ObjectMapper objectMapper,
DocumentService documentService); @KafkaListener(topics = "${kafka.topics.egov.index.name}") void listen(HashMap<String, Object> sevaRequestMap); }### Answer:
@Test public void test_should_index_document() throws UnsupportedEncodingException { final ServiceRequestDocument expectedDocumentToIndex = new ServiceRequestDocument(); final HashMap<String, Object> sevaRequestMap = getSevaRequestMap(); when(documentService.enrich(any(SevaRequest.class))).thenReturn(expectedDocumentToIndex); indexerListener.listen(sevaRequestMap); verify(elasticSearchRepository).index(expectedDocumentToIndex); }
|
### Question:
PipeSizeService { public List<PipeSize> getPipeSizes(final PipeSizeGetRequest pipeSizeGetRequest) { return pipeSizeRepository.findForCriteria(pipeSizeGetRequest); } PipeSizeRequest create(final PipeSizeRequest pipeSizeRequest); PipeSizeRequest update(final PipeSizeRequest pipeSizeRequest); List<PipeSize> pushCreateToQueue(final String topic, final String key, final PipeSizeRequest pipeSizeRequest); List<PipeSize> pushUpdateToQueue(final String topic, final String key, final PipeSizeRequest pipeSizeRequest); boolean getPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId); List<PipeSize> getPipeSizes(final PipeSizeGetRequest pipeSizeGetRequest); }### Answer:
@Test public void test_Should_Get_PipeSizes() throws Exception { final PipeSizeGetRequest pipeSizeGetRequest = new PipeSizeGetRequest(); final PipeSize pipeSize = new PipeSize(); pipeSize.setCode("10"); pipeSize.setActive(true); final List<PipeSize> pipeSizes = new ArrayList<>(); List<PipeSize> pipeSizesResult = new ArrayList<>(); pipeSizes.add(pipeSize); when(pipeSizeRepository.findForCriteria(pipeSizeGetRequest)).thenReturn(pipeSizes); pipeSizesResult = pipeSizeService.getPipeSizes(pipeSizeGetRequest); assertTrue(null != pipeSizesResult); }
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException_Get_PipeSizes() throws Exception { final PipeSizeGetRequest pipeSizeGetRequest = new PipeSizeGetRequest(); final PipeSize pipeSize = new PipeSize(); pipeSize.setCode("10"); pipeSize.setActive(true); final List<PipeSize> pipeSizes = new ArrayList<>(); List<PipeSize> pipeSizesResult = new ArrayList<>(); pipeSizes.add(pipeSize); when(pipeSizeRepository.findForCriteria(pipeSizeGetRequest)).thenThrow(Exception.class); pipeSizesResult = pipeSizeService.getPipeSizes(pipeSizeGetRequest); assertTrue(null != pipeSizesResult); }
|
### Question:
TreatmentPlantService { public List<TreatmentPlant> getTreatmentPlant(final TreatmentPlantGetRequest treatmentPlantGetRequest) { return treatmentPlantRepository.findForCriteria(treatmentPlantGetRequest); } TreatmentPlantRequest create(final TreatmentPlantRequest treatmentPlantRequest); TreatmentPlantRequest update(final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> pushCreateToQueue(final String topic, final String key,
final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> pushUpdateToQueue(final String topic, final String key,
final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> getTreatmentPlant(final TreatmentPlantGetRequest treatmentPlantGetRequest); boolean getTreatmentPlantByNameAndCode(final String code, final String name, final String tenantId); boolean checkStorageReservoirExists(final String storageReservoirName, final String tenantId); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_Should_Search_TreatmentPlant() { final List<TreatmentPlant> treatmentPlantList = new ArrayList<>(); treatmentPlantList.add(getTreatmentPlant()); final TreatmentPlantGetRequest treatmentPlantGetRequest = Mockito.mock(TreatmentPlantGetRequest.class); when(treatmentPlantRepository.findForCriteria(treatmentPlantGetRequest)).thenThrow(Exception.class); assertTrue(treatmentPlantList.equals(treatmentPlantService.getTreatmentPlant(treatmentPlantGetRequest))); }
|
### Question:
TreatmentPlantService { public TreatmentPlantRequest update(final TreatmentPlantRequest treatmentPlantRequest) { return treatmentPlantRepository.update(treatmentPlantRequest); } TreatmentPlantRequest create(final TreatmentPlantRequest treatmentPlantRequest); TreatmentPlantRequest update(final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> pushCreateToQueue(final String topic, final String key,
final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> pushUpdateToQueue(final String topic, final String key,
final TreatmentPlantRequest treatmentPlantRequest); List<TreatmentPlant> getTreatmentPlant(final TreatmentPlantGetRequest treatmentPlantGetRequest); boolean getTreatmentPlantByNameAndCode(final String code, final String name, final String tenantId); boolean checkStorageReservoirExists(final String storageReservoirName, final String tenantId); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException_Update_TreatmentPlant() throws Exception { final TreatmentPlantRequest treatmentPlantRequest = Mockito.mock(TreatmentPlantRequest.class); when(treatmentPlantRepository.update(treatmentPlantRequest)).thenThrow(Exception.class); assertTrue(treatmentPlantRequest.equals(treatmentPlantService.update(treatmentPlantRequest))); }
|
### Question:
SupplyTypeService { public List<SupplyType> getSupplyTypes(final SupplyTypeGetRequest supplytypeGetRequest) { return supplyTypeRepository.findForCriteria(supplytypeGetRequest); } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushCreateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushUpdateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); boolean getSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> getSupplyTypes(final SupplyTypeGetRequest supplytypeGetRequest); }### Answer:
@Test public void test_Should_Search_WaterSource() { final List<SupplyType> supplyTypes = new ArrayList<>(); supplyTypes.add(getSupplyType()); when(supplyTypeRepository.findForCriteria(any(SupplyTypeGetRequest.class))).thenReturn(supplyTypes); assertTrue(supplyTypes.equals(supplyTypeService.getSupplyTypes(any(SupplyTypeGetRequest.class)))); }
|
### Question:
SupplyTypeService { public List<SupplyType> pushCreateToQueue(final String topic, final String key, final SupplyTypeRequest supplyTypeRequest) { for (final SupplyType supplyType : supplyTypeRequest.getSupplyTypes()) { supplyType.setCode(codeGeneratorService.generate(SupplyType.SEQ_SUPPLYTYPE)); } return mapRequestObjectToWaterProducer(topic, key, supplyTypeRequest); } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushCreateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushUpdateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); boolean getSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> getSupplyTypes(final SupplyTypeGetRequest supplytypeGetRequest); }### Answer:
@Test public void test_throwException_Push_To_Producer_SupplyType() { final List<SupplyType> supplyTypeList = new ArrayList<>(); supplyTypeList.add(getSupplyType()); final SupplyTypeRequest supplyTypeRequest = new SupplyTypeRequest(); supplyTypeRequest.setSupplyTypes(supplyTypeList); assertTrue(supplyTypeList.equals(supplyTypeService.pushCreateToQueue("topic", "key", supplyTypeRequest))); }
|
### Question:
SupplyTypeService { public SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest) { return supplyTypeRepository.create(supplyTypeRequest); } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushCreateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushUpdateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); boolean getSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> getSupplyTypes(final SupplyTypeGetRequest supplytypeGetRequest); }### Answer:
@Test public void test_throwException_Create_WaterSource() { final List<SupplyType> supplyTypeList = new ArrayList<>(); supplyTypeList.add(getSupplyType()); final SupplyTypeRequest supplyTypeRequest = new SupplyTypeRequest(); supplyTypeRequest.setSupplyTypes(supplyTypeList); when(supplyTypeService.create(any(SupplyTypeRequest.class))) .thenReturn(supplyTypeRequest); assertTrue(supplyTypeRequest.equals(supplyTypeService.create(supplyTypeRequest))); }
|
### Question:
SupplyTypeService { public SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest) { return supplyTypeRepository.update(supplyTypeRequest); } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushCreateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); List<SupplyType> pushUpdateToQueue(final String topic, final String key,
final SupplyTypeRequest supplyTypeRequest); boolean getSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> getSupplyTypes(final SupplyTypeGetRequest supplytypeGetRequest); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException_Update_WaterSource() throws Exception { final SupplyTypeRequest supplyTypeRequest = Mockito.mock(SupplyTypeRequest.class); when(supplyTypeService.update(supplyTypeRequest)).thenThrow(Exception.class); assertTrue(supplyTypeRequest.equals(supplyTypeService.update(supplyTypeRequest))); }
|
### Question:
DocumentTypeService { public List<DocumentType> getDocumentTypes(final DocumentTypeGetReq documentTypeGetRequest) { return documentTypeRepository.findForCriteria(documentTypeGetRequest); } DocumentTypeReq create(final DocumentTypeReq documentTypeReq); DocumentTypeReq update(final DocumentTypeReq documentTypeReq); List<DocumentType> pushCreateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); List<DocumentType> pushUpdateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); boolean getDocumentTypeByNameAndCode(final String code, final String name, final String tenantId); List<DocumentType> getDocumentTypes(final DocumentTypeGetReq documentTypeGetRequest); List<Long> getAllMandatoryDocs(final String applicationType); }### Answer:
@Test public void test_Search_For_DocumentTypeServices() { final List<DocumentType> documentTypeList = new ArrayList<>(); final DocumentType docType = Mockito.mock(DocumentType.class); documentTypeList.add(docType); when(documentRepository.findForCriteria(any(DocumentTypeGetReq.class))).thenReturn(documentTypeList); assertTrue(documentTypeList.equals(docTypeService.getDocumentTypes(any(DocumentTypeGetReq.class)))); }
@Test public void test_Search_For_DocumentType_Notnull() { final List<DocumentType> docTypeList = new ArrayList<>(); final DocumentType docType = Mockito.mock(DocumentType.class); docTypeList.add(docType); when(documentRepository.findForCriteria(any(DocumentTypeGetReq.class))).thenReturn(docTypeList); assertNotNull(docTypeService.getDocumentTypes(any(DocumentTypeGetReq.class))); }
@Test public void test_Search_For_Document_Types_Null() { final List<DocumentType> docTypeList = new ArrayList<>(); final DocumentType docType = Mockito.mock(DocumentType.class); docTypeList.add(docType); when(documentRepository.findForCriteria(any(DocumentTypeGetReq.class))).thenReturn(null); assertNull(docTypeService.getDocumentTypes(any(DocumentTypeGetReq.class))); }
|
### Question:
DocumentTypeService { public DocumentTypeReq create(final DocumentTypeReq documentTypeReq) { return documentTypeRepository.create(documentTypeReq); } DocumentTypeReq create(final DocumentTypeReq documentTypeReq); DocumentTypeReq update(final DocumentTypeReq documentTypeReq); List<DocumentType> pushCreateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); List<DocumentType> pushUpdateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); boolean getDocumentTypeByNameAndCode(final String code, final String name, final String tenantId); List<DocumentType> getDocumentTypes(final DocumentTypeGetReq documentTypeGetRequest); List<Long> getAllMandatoryDocs(final String applicationType); }### Answer:
@Test public void test_Should_DocumentType_Create() { final List<DocumentType> docTypes = new ArrayList<>(); docTypes.add(getDocumentType()); final DocumentTypeReq docTypeReq = new DocumentTypeReq(); docTypeReq.setDocumentTypes(docTypes); final DocumentTypeRes propUsageTypeResponse = new DocumentTypeRes(); propUsageTypeResponse.setResponseInfo(null); propUsageTypeResponse.setDocumentTypes(docTypes); when(docTypeService.create(any(DocumentTypeReq.class))).thenReturn(docTypeReq); assertTrue(docTypeReq.equals(docTypeService.create(docTypeReq))); }
|
### Question:
DocumentTypeService { public List<DocumentType> pushCreateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq) { for (final DocumentType documentType : documentTypeReq.getDocumentTypes()) documentType.setCode(codeGeneratorService.generate(DocumentType.SEQ_DOCUMENTTYPE)); try { kafkaTemplate.send(topic, key, documentTypeReq); } catch (final Exception ex) { log.error("Exception Encountered : " + ex); } return documentTypeReq.getDocumentTypes(); } DocumentTypeReq create(final DocumentTypeReq documentTypeReq); DocumentTypeReq update(final DocumentTypeReq documentTypeReq); List<DocumentType> pushCreateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); List<DocumentType> pushUpdateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); boolean getDocumentTypeByNameAndCode(final String code, final String name, final String tenantId); List<DocumentType> getDocumentTypes(final DocumentTypeGetReq documentTypeGetRequest); List<Long> getAllMandatoryDocs(final String applicationType); }### Answer:
@Test public void test_Should_Update_DocumentType_NotNull() throws Exception { final DocumentTypeReq docTypeRequest = new DocumentTypeReq(); final RequestInfo requestInfo = new RequestInfo(); final User user = new User(); user.setId(1L); requestInfo.setUserInfo(user); final List<DocumentType> docTypeList = new ArrayList<>(); docTypeList.add(getDocumentType()); docTypeRequest.setRequestInfo(requestInfo); docTypeRequest.setDocumentTypes(docTypeList); final List<DocumentType> docTypeResult = docTypeService.pushCreateToQueue("topic", "key", docTypeRequest); assertNotNull(docTypeResult); }
|
### Question:
DocumentTypeService { public DocumentTypeReq update(final DocumentTypeReq documentTypeReq) { return documentTypeRepository.update(documentTypeReq); } DocumentTypeReq create(final DocumentTypeReq documentTypeReq); DocumentTypeReq update(final DocumentTypeReq documentTypeReq); List<DocumentType> pushCreateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); List<DocumentType> pushUpdateToQueue(final String topic, final String key, final DocumentTypeReq documentTypeReq); boolean getDocumentTypeByNameAndCode(final String code, final String name, final String tenantId); List<DocumentType> getDocumentTypes(final DocumentTypeGetReq documentTypeGetRequest); List<Long> getAllMandatoryDocs(final String applicationType); }### Answer:
@Test public void test_Should_Update_DocumentType() { final List<DocumentType> docTypesList = new ArrayList<>(); docTypesList.add(getDocumentType()); final DocumentTypeReq docTypeRequest = new DocumentTypeReq(); docTypeRequest.setDocumentTypes(docTypesList); final DocumentTypeRes docTypeResponse = new DocumentTypeRes(); docTypeResponse.setResponseInfo(null); docTypeResponse.setDocumentTypes(docTypesList); when(docTypeService.update(any(DocumentTypeReq.class))).thenReturn(docTypeRequest); assertTrue(docTypeRequest.equals(docTypeService.update(docTypeRequest))); }
|
### Question:
MeterWaterRatesService { public List<MeterWaterRates> getMeterWaterRates( final MeterWaterRatesGetRequest meterWaterRatesGetRequest) { return meterWaterRatesRepository.findForCriteria(meterWaterRatesGetRequest); } MeterWaterRatesRequest create(final MeterWaterRatesRequest meterWaterRatesRequest); MeterWaterRatesRequest update(final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> pushCreateToQueue(final String topic, final String key,
final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> pushUpdateToQueue(final String topic, final String key,
final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> getMeterWaterRates(
final MeterWaterRatesGetRequest meterWaterRatesGetRequest); boolean checkMeterWaterRatesExists(final MeterWaterRates meterWaterRates); boolean checkPipeSizeExists(final Double pipeSize, final String tenantId); boolean checkSourceTypeExists(final String sourceTypeName, final String tenantId); boolean isUsageTypeExists(final MeterWaterRates meterWaterRates); boolean isSubUsageTypeExists(final MeterWaterRates meterWaterRates); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_Should_Search_MeterWaterRates() { final List<MeterWaterRates> meterWaterRatesList = new ArrayList<>(); meterWaterRatesList.add(getMeterWaterRates()); final MeterWaterRatesGetRequest meterWaterRatesRequest = Mockito.mock(MeterWaterRatesGetRequest.class); when(meterWaterRatesRepository.findForCriteria(meterWaterRatesRequest)).thenThrow(Exception.class); assertTrue(meterWaterRatesList .equals(meterWaterRatesService.getMeterWaterRates(meterWaterRatesRequest))); }
|
### Question:
MeterWaterRatesService { public MeterWaterRatesRequest update(final MeterWaterRatesRequest meterWaterRatesRequest) { return meterWaterRatesRepository.update(meterWaterRatesRequest); } MeterWaterRatesRequest create(final MeterWaterRatesRequest meterWaterRatesRequest); MeterWaterRatesRequest update(final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> pushCreateToQueue(final String topic, final String key,
final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> pushUpdateToQueue(final String topic, final String key,
final MeterWaterRatesRequest meterWaterRatesRequest); List<MeterWaterRates> getMeterWaterRates(
final MeterWaterRatesGetRequest meterWaterRatesGetRequest); boolean checkMeterWaterRatesExists(final MeterWaterRates meterWaterRates); boolean checkPipeSizeExists(final Double pipeSize, final String tenantId); boolean checkSourceTypeExists(final String sourceTypeName, final String tenantId); boolean isUsageTypeExists(final MeterWaterRates meterWaterRates); boolean isSubUsageTypeExists(final MeterWaterRates meterWaterRates); }### Answer:
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException_Update_MeterWaterRates() throws Exception { final MeterWaterRatesRequest meterWaterRatesRequest = Mockito.mock(MeterWaterRatesRequest.class); when(meterWaterRatesRepository.update(meterWaterRatesRequest)).thenThrow(Exception.class); assertTrue(meterWaterRatesRequest.equals(meterWaterRatesService.update(meterWaterRatesRequest))); }
|
### Question:
MeterCostService { public List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest) { logger.info("Pushing meterCostCreateRequest To Queue"); logger.info("MeterCostReq :" + meterCostRequest); return meterCostRepository.pushCreateToQueue(meterCostRequest); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_push_create_meterCostRequest_to_Queue() { when(meterCostRepository.pushCreateToQueue(getMeterCostRequest())) .thenReturn(getListOfMeterCosts()); final List<MeterCost> actualMeterCosts = meterCostService.pushCreateToQueue(getMeterCostRequest()); assertTrue(actualMeterCosts.equals(getListOfMeterCosts())); }
|
### Question:
MeterCostService { public List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest) { logger.info("Pushing meterCostUpdateRequest To Queue"); logger.info("MeterCostReq :" + meterCostRequest); return meterCostRepository.pushUpdateToQueue(meterCostRequest); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_push_update_meterCostRequest_to_Queue() { when(meterCostRepository.pushUpdateToQueue(getMeterCostRequestForUpdate())) .thenReturn(getListOfUpdatedMeterCosts()); final List<MeterCost> actualMeterCosts = meterCostService.pushUpdateToQueue(getMeterCostRequestForUpdate()); assertTrue(actualMeterCosts.equals(getListOfUpdatedMeterCosts())); }
|
### Question:
MeterCostService { public MeterCostReq create(final MeterCostReq meterCostRequest) { logger.info("MeterCostReq :" + meterCostRequest); return meterCostRepository.create(meterCostRequest); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_persist_meterCost_to_DB() { when(meterCostRepository.create(getMeterCostRequest())).thenReturn(getMeterCostRequest()); final MeterCostReq actualMeterCostRequest = meterCostService.create(getMeterCostRequest()); assertTrue(actualMeterCostRequest.equals(getMeterCostRequest())); }
|
### Question:
MeterCostService { public MeterCostReq update(final MeterCostReq meterCostRequest) { logger.info("MeterCostReq :" + meterCostRequest); return meterCostRepository.update(meterCostRequest); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_update_meterCost_in_DB() { when(meterCostRepository.update(getMeterCostRequestForUpdate())) .thenReturn(getMeterCostRequestForUpdate()); final MeterCostReq actualMeterCostRequest = meterCostService.update(getMeterCostRequestForUpdate()); assertTrue(actualMeterCostRequest.equals(getMeterCostRequestForUpdate())); }
|
### Question:
MeterCostService { public List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest) { return meterCostRepository.searchMeterCostByCriteria(meterCostGetRequest); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_search_meterCost_as_per_Criteria() { when(meterCostRepository.searchMeterCostByCriteria(getMeterCostGetRequest())).thenReturn(getListOfMeterCosts()); final List<MeterCost> actualListOfMeterCosts = meterCostService.getMeterCostByCriteria(getMeterCostGetRequest()); assertTrue(actualListOfMeterCosts.get(0).getCode().equals(getListOfMeterCosts().get(0).getCode())); assertTrue(actualListOfMeterCosts.get(0).getMeterMake().equals(getListOfMeterCosts().get(0).getMeterMake())); assertTrue(actualListOfMeterCosts.get(1).getCode().equals(getListOfMeterCosts().get(1).getCode())); assertTrue(actualListOfMeterCosts.get(1).getMeterMake().equals(getListOfMeterCosts().get(1).getMeterMake())); }
|
### Question:
MeterCostService { public boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost) { return meterCostRepository.checkMeterMakeAndAmountAlreadyExists(meterCost); } List<MeterCost> pushCreateToQueue(final MeterCostReq meterCostRequest); MeterCostReq create(final MeterCostReq meterCostRequest); List<MeterCost> pushUpdateToQueue(final MeterCostReq meterCostRequest); MeterCostReq update(final MeterCostReq meterCostRequest); List<MeterCost> getMeterCostByCriteria(final MeterCostGetRequest meterCostGetRequest); boolean checkMeterMakeAndAmountAlreadyExists(final MeterCost meterCost); static final Logger logger; }### Answer:
@Test public void test_should_check_meterCost_exists_and_return_true_if_it_doesnot_exists_in_DB() { when(meterCostRepository.checkMeterMakeAndAmountAlreadyExists(getMeterCost())).thenReturn(true); final Boolean value = meterCostService.checkMeterMakeAndAmountAlreadyExists(getMeterCost()); assertTrue(value.equals(true)); }
@Test public void test_should_check_meterCost_exists_and_return_false_if_it_exists_in_DB() { when(meterCostRepository.checkMeterMakeAndAmountAlreadyExists(getMeterCost())).thenReturn(false); final Boolean value = meterCostService.checkMeterMakeAndAmountAlreadyExists(getMeterCost()); assertTrue(value.equals(false)); }
|
### Question:
ServiceChargeService { public List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest) { final List<ServiceCharge> serviceCharges = serviceChargeRequest.getServiceCharge(); for (final ServiceCharge serviceCharge : serviceCharges) serviceCharge.setCode(codeGeneratorService.generate(ServiceCharge.SEQ_SERVICECHARGE)); logger.info("ServiceChargeReq :" + serviceChargeRequest); final List<ServiceCharge> serviceChargess = serviceChargeRepository .pushCreateToQueue(serviceChargeRequest); return serviceChargess; } List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_push_create_ServiceCharge_to_Queue() { when(codeGeneratorService.generate("SEQ_EGWTR_SERVICECHARGE")).thenReturn("1", "2", "3", "4"); when(serviceChargeRepository.pushCreateToQueue(getServiceChargeRequestAfterCodeAppend())) .thenReturn(getListOfServiceCharges()); assertTrue(getListOfServiceCharges().equals(serviceChargeService .pushCreateToQueue(getServiceChargeRequest()))); }
|
### Question:
ServiceChargeService { public List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest) { logger.info("ServiceChargeReq :" + serviceChargeRequest); return serviceChargeRepository.pushUpdateToQueue(serviceChargeRequest); } List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_push_update_serviceCharge_to_queue() { when(serviceChargeRepository.pushUpdateToQueue(getServiceChargeRequest())) .thenReturn(getListOfServiceCharges()); assertTrue(getListOfServiceCharges() .equals(serviceChargeService.pushUpdateToQueue(getServiceChargeRequest()))); }
|
### Question:
ServiceChargeService { public ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest) { return serviceChargeRepository.create(serviceChargeRequest); } List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_create_serviceCharge() { when(serviceChargeRepository.create(getServiceChargeRequest())) .thenReturn(getServiceChargeRequest()); assertTrue(getServiceChargeRequest().equals(serviceChargeService.create(getServiceChargeRequest()))); }
|
### Question:
ServiceChargeService { public ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest) { return serviceChargeRepository.update(serviceChargeRequest); } List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_update_serviceCharge() { when(serviceChargeRepository.update(getServiceChargeRequest())) .thenReturn(getServiceChargeRequest()); assertTrue(getServiceChargeRequest().equals(serviceChargeService.update(getServiceChargeRequest()))); }
|
### Question:
ServiceChargeService { public List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest) { return serviceChargeRepository.searchServiceChargesByCriteria(serviceChargeGetRequest); } List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> getServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_search_serviceCharge_by_criteria() { when(serviceChargeRepository.searchServiceChargesByCriteria(getServiceChargeGetCriteria())) .thenReturn(getListOfServiceChargesForSearch()); assertTrue(getListOfServiceChargesForSearch() .equals(serviceChargeService.getServiceChargesByCriteria(getServiceChargeGetCriteria()))); }
|
### Question:
UsageTypeService { public UsageTypeReq create(final UsageTypeReq usageTypeRequest) { return usageTypeRepository.create(usageTypeRequest); } List<UsageType> getUsageTypes(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq update(final UsageTypeReq usageTypeRequest); }### Answer:
@Test public void test_should_persist_create_usageType_request_to_DB() { when(usageTypeRepository.create(getUsageTypeRequest())).thenReturn(getUsageTypeRequest()); final UsageTypeReq usageTypeRequest = usageTypeService.create(getUsageTypeRequest()); assertTrue(getUsageTypeRequest().equals(usageTypeRequest)); }
|
### Question:
ServiceGroupService { public ServiceGroupRequest create(final ServiceGroupRequest serviceGroupRequest) { logger.info("Persisting service group record"); return categoryRepository.persistCreateServiceGroup(serviceGroupRequest); } ServiceGroupRequest create(final ServiceGroupRequest serviceGroupRequest); ServiceGroupRequest update(final ServiceGroupRequest serviceGroupRequest); ServiceGroup createCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); ServiceGroup updateCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); List<ServiceGroup> getAllServiceGroup(ServiceGroupGetRequest serviceGroupGetRequest); boolean verifyRequestUniqueness(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfNameAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfCodeAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); static final Logger logger; }### Answer:
@Test public void test_should_create_service_group() { ServiceGroupRequest serviceGroupRequest = prepareServiceGroupRequest(); serviceGroupService.create(serviceGroupRequest); verify(serviceGroupRepository).persistCreateServiceGroup(serviceGroupRequest); }
|
### Question:
UsageTypeService { public UsageTypeReq update(final UsageTypeReq usageTypeRequest) { return usageTypeRepository.update(usageTypeRequest); } List<UsageType> getUsageTypes(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq update(final UsageTypeReq usageTypeRequest); }### Answer:
@Test public void test_should_update_usageType_request_in_DB() { when(usageTypeRepository.update(getUsageTypeRequestForUpdate())) .thenReturn(getUsageTypeRequestForUpdate()); final UsageTypeReq usageTypeRequest = usageTypeService.update(getUsageTypeRequestForUpdate()); assertTrue(getUsageTypeRequestForUpdate().equals(usageTypeRequest)); }
|
### Question:
UsageTypeService { public List<UsageType> getUsageTypes(final UsageTypeGetRequest usageTypeGetRequest) { return usageTypeRepository.getUsageTypesByCriteria(usageTypeGetRequest); } List<UsageType> getUsageTypes(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); UsageTypeReq update(final UsageTypeReq usageTypeRequest); }### Answer:
@Test public void test_should_search_usageType_from_DB() { when(usageTypeRepository.getUsageTypesByCriteria(getUsageTypeGetRequest())).thenReturn(getUsageType()); final List<UsageType> usageTypes = usageTypeService.getUsageTypes(getUsageTypeGetRequest()); assertTrue(getUsageType().equals(usageTypes)); }
|
### Question:
DonationService { public DonationRequest create(final DonationRequest donationRequest) { return donationRepository.create(donationRequest); } DonationRequest create(final DonationRequest donationRequest); DonationRequest update(final DonationRequest donationRequest); List<Donation> pushCreateToQueue(final String topic, final String key, final DonationRequest donationRequest); List<Donation> pushUpdateToQueue(final String topic, final String key, final DonationRequest donationRequest); List<Donation> getDonationList(final DonationGetRequest donationGetRequest); boolean checkDonationsExist(final Donation donation); boolean checkPipeSizeExists(final Double pipeSize, final String tenantId); boolean checkUsageAndSubUsageExists(final String usageType, final String tenantId); }### Answer:
@Test public void test_Should_Donation_Create() { final List<Donation> donationList = new ArrayList<>(); donationList.add(getDonation()); final DonationRequest donationReq = new DonationRequest(); donationReq.setDonations(donationList); final DonationResponse donationResponse = new DonationResponse(); donationResponse.setResponseInfo(null); donationResponse.setDonations(donationList); when(donationService.create(any(DonationRequest.class))).thenReturn(donationReq); assertTrue(donationReq.equals(donationService.create(donationReq))); }
|
### Question:
DonationService { public List<Donation> pushCreateToQueue(final String topic, final String key, final DonationRequest donationRequest) { for (final Donation donation : donationRequest.getDonations()) donation.setCode(codeGeneratorService.generate(Donation.SEQ_DONATION)); try { kafkaTemplate.send(topic, key, donationRequest); } catch (final Exception ex) { log.error("Exception Encountered : " + ex); } return donationRequest.getDonations(); } DonationRequest create(final DonationRequest donationRequest); DonationRequest update(final DonationRequest donationRequest); List<Donation> pushCreateToQueue(final String topic, final String key, final DonationRequest donationRequest); List<Donation> pushUpdateToQueue(final String topic, final String key, final DonationRequest donationRequest); List<Donation> getDonationList(final DonationGetRequest donationGetRequest); boolean checkDonationsExist(final Donation donation); boolean checkPipeSizeExists(final Double pipeSize, final String tenantId); boolean checkUsageAndSubUsageExists(final String usageType, final String tenantId); }### Answer:
@Test public void test_throwException_Push_To_Producer_Donation() { final List<Donation> donationList = new ArrayList<>(); donationList.add(getDonation()); final DonationRequest donationRequest = new DonationRequest(); donationRequest.setDonations(donationList); assertTrue(donationList.equals(donationService.pushCreateToQueue("", "", donationRequest))); }
|
### Question:
ServiceChargeRepository { public List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest) { logger.info("Pushing ServiceChargeCreateRequest to queue"); try { kafkaTemplate.send(applicationProperties.getCreateServiceChargeTopicName(), serviceChargeRequest); } catch (final Exception e) { logger.error("Exception Encountered :" + e); } return serviceChargeRequest.getServiceCharge(); } @SuppressWarnings("unchecked") ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); @SuppressWarnings("unchecked") ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> searchServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); List<ServiceCharge> convertToModel(final List<ServiceCharge> listOfServiceChargesFromDB,
final List<ServiceChargeDetails> serviceChargeDetails); static final String TENANT; static final String SERVICECHARGE; static final Logger logger; }### Answer:
@Test public void test_should_push_create_serviceCharge_to_queue() { when(applicationProperties.getCreateServiceChargeTopicName()).thenReturn("egov.wcms.servicecharge-create"); serviceChargeRepository.pushCreateToQueue(getServiceChargeRequest()); verify(kafkaTemplate).send("egov.wcms.servicecharge-create", getServiceChargeRequest()); }
|
### Question:
ServiceChargeRepository { public List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest) { logger.info("Pushing ServiceChargeUpdateRequest to queue"); try { kafkaTemplate.send(applicationProperties.getUpdateServiceChargeTopicName(), serviceChargeRequest); } catch (final Exception e) { logger.error("Exception Encountered :" + e); } return serviceChargeRequest.getServiceCharge(); } @SuppressWarnings("unchecked") ServiceChargeReq create(final ServiceChargeReq serviceChargeRequest); @SuppressWarnings("unchecked") ServiceChargeReq update(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushCreateToQueue(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> pushUpdateToQueue(final ServiceChargeReq serviceChargeRequest); List<ServiceCharge> searchServiceChargesByCriteria(final ServiceChargeGetRequest serviceChargeGetRequest); List<ServiceCharge> convertToModel(final List<ServiceCharge> listOfServiceChargesFromDB,
final List<ServiceChargeDetails> serviceChargeDetails); static final String TENANT; static final String SERVICECHARGE; static final Logger logger; }### Answer:
@Test public void test_should_push_update_serviceCharge_to_queue() { when(applicationProperties.getUpdateServiceChargeTopicName()).thenReturn("egov.wcms.servicecharge-update"); serviceChargeRepository.pushUpdateToQueue(getServiceChargeRequest()); verify(kafkaTemplate).send("egov.wcms.servicecharge-update", getServiceChargeRequest()); }
|
### Question:
ServiceGroupService { public ServiceGroupRequest update(final ServiceGroupRequest serviceGroupRequest) { logger.info("Updating service group record"); return categoryRepository.persistUpdateServiceGroup(serviceGroupRequest); } ServiceGroupRequest create(final ServiceGroupRequest serviceGroupRequest); ServiceGroupRequest update(final ServiceGroupRequest serviceGroupRequest); ServiceGroup createCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); ServiceGroup updateCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); List<ServiceGroup> getAllServiceGroup(ServiceGroupGetRequest serviceGroupGetRequest); boolean verifyRequestUniqueness(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfNameAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfCodeAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); static final Logger logger; }### Answer:
@Test public void test_should_update_service_group_details() { ServiceGroupRequest serviceGroupRequest = prepareServiceGroupRequest(); serviceGroupService.update(serviceGroupRequest); verify(serviceGroupRepository).persistUpdateServiceGroup(serviceGroupRequest); }
|
### Question:
PipeSizeRepository { public boolean checkPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId) { final List<Object> preparedStatementValues = new ArrayList<>(); preparedStatementValues.add(sizeInMilimeter); preparedStatementValues.add(tenantId); final String query; if (code == null) query = PipeSizeQueryBuilder.selectPipeSizeInmmAndCodeQuery(); else { preparedStatementValues.add(code); query = PipeSizeQueryBuilder.selectPipeSizeInmmAndCodeNotInQuery(); } final List<Map<String, Object>> pipeSizes = jdbcTemplate.queryForList(query, preparedStatementValues.toArray()); if (!pipeSizes.isEmpty()) return false; return true; } PipeSizeRequest create(final PipeSizeRequest pipeSizeRequest); PipeSizeRequest update(final PipeSizeRequest pipeSizeRequest); boolean checkPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId); List<PipeSize> findForCriteria(final PipeSizeGetRequest pipeSizeGetRequest); }### Answer:
@Test public void test_Should_Check_PipeSize() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); preparedStatementValues.add(1.22); preparedStatementValues.add(1.45); assertNotNull(pipeSizeRepository.checkPipeSizeInmmAndCode("ABC", 1.22, "1")); }
|
### Question:
PipeSizeRepository { public List<PipeSize> findForCriteria(final PipeSizeGetRequest pipeSizeGetRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = pipeSizeQueryBuilder.getQuery(pipeSizeGetRequest, preparedStatementValues); final List<PipeSize> pipeSizes = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), pipeSizeRowMapper); return pipeSizes; } PipeSizeRequest create(final PipeSizeRequest pipeSizeRequest); PipeSizeRequest update(final PipeSizeRequest pipeSizeRequest); boolean checkPipeSizeInmmAndCode(final String code, final Double sizeInMilimeter, final String tenantId); List<PipeSize> findForCriteria(final PipeSizeGetRequest pipeSizeGetRequest); }### Answer:
@Test public void test_Should__FindforCriteria() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); final PipeSizeGetRequest pipeSizeGetRequest = new PipeSizeGetRequest(); when(pipeSizeQueryBuilder.getQuery(pipeSizeGetRequest, preparedStatementValues)).thenReturn("query"); final List<PipeSize> pipeSizes = pipeSizeRepository.findForCriteria(pipeSizeGetRequest); assertTrue(pipeSizes != null); }
@SuppressWarnings("unchecked") @Test(expected = Exception.class) public void test_throwException__FindforCriteria() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); final PipeSizeGetRequest pipeSizeGetRequest = new PipeSizeGetRequest(); when(pipeSizeQueryBuilder.getQuery(pipeSizeGetRequest, preparedStatementValues)).thenThrow(Exception.class); final List<PipeSize> pipeSizes = pipeSizeRepository.findForCriteria(pipeSizeGetRequest); assertTrue(pipeSizes != null); }
|
### Question:
MeterStatusRepository { public List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq) { logger.info("Sending MeterStatusRequest to queue"); final List<MeterStatus> meterStatuses = meterStatusReq.getMeterStatus(); for (final MeterStatus meterStatus : meterStatuses) meterStatus.setCode(codeGeneratorService.generate(MeterStatus.SEQ_METER_STATUS)); try { kafkaTemplate.send(applicationProperties.getCreateMeterStatusTopicName(), meterStatusReq); } catch (final Exception e) { logger.error("Exception encountered:" + e); } return meterStatusReq.getMeterStatus(); } List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq); MeterStatusReq create(final MeterStatusReq meterStatusRequest); List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest); MeterStatusReq update(final MeterStatusReq meterStatusRequest); List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_create_meterStatus_and_push_to_queue() { when(codeGeneratorService.generate("SEQ_EGWTR_METERSTATUS")).thenReturn("1", "2"); when(applicationProperties.getCreateMeterStatusTopicName()).thenReturn("egov.wcms.meterstatus-create"); meterStatusRepository.pushCreateToQueue(getMeterStatusRequest()); verify(kafkaTemplate).send("egov.wcms.meterstatus-create", getMeterStatusRequestAfterCodeAppend()); }
|
### Question:
ServiceGroupService { public List<ServiceGroup> getAllServiceGroup(ServiceGroupGetRequest serviceGroupGetRequest) { return categoryRepository.getAllServiceGroup(serviceGroupGetRequest); } ServiceGroupRequest create(final ServiceGroupRequest serviceGroupRequest); ServiceGroupRequest update(final ServiceGroupRequest serviceGroupRequest); ServiceGroup createCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); ServiceGroup updateCategory(final String topic, final String key,
final ServiceGroupRequest serviceGroupRequest); List<ServiceGroup> getAllServiceGroup(ServiceGroupGetRequest serviceGroupGetRequest); boolean verifyRequestUniqueness(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfNameAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); boolean verifyIfCodeAlreadyExists(ServiceGroupRequest serviceGroupRequest, String action); static final Logger logger; }### Answer:
@Test public void test_should_return_list_of_service_groups() { List<ServiceGroup> serviceGroupList = prepareServiceGroupObjectList(); when(serviceGroupRepository.getAllServiceGroup(any(ServiceGroupGetRequest.class))).thenReturn(serviceGroupList); assertTrue(serviceGroupList.equals(serviceGroupRepository.getAllServiceGroup(any(ServiceGroupGetRequest.class)))); }
|
### Question:
MeterStatusRepository { public List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest) { logger.info("Sending MeterStatusRequest to queue"); try { kafkaTemplate.send(applicationProperties.getUpdateMeterStatusTopicName(), meterStatusRequest); } catch (final Exception e) { logger.error("Exception encountered:" + e); } return meterStatusRequest.getMeterStatus(); } List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq); MeterStatusReq create(final MeterStatusReq meterStatusRequest); List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest); MeterStatusReq update(final MeterStatusReq meterStatusRequest); List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_update_meterStatus_and_push_to_queue() { when(applicationProperties.getUpdateMeterStatusTopicName()).thenReturn("egov.wcms.meterstatus-update"); meterStatusRepository.pushUpdateToQueue(getMeterStatusRequestForUpdate()); verify(kafkaTemplate).send("egov.wcms.meterstatus-update", getMeterStatusRequestForUpdate()); }
|
### Question:
MeterStatusRepository { public MeterStatusReq create(final MeterStatusReq meterStatusRequest) { final List<MeterStatus> meterStatuses = meterStatusRequest.getMeterStatus(); final List<Map<String, Object>> batchValues = new ArrayList<>(meterStatuses.size()); for (final MeterStatus meterStatus : meterStatuses) batchValues.add(new MapSqlParameterSource("id", Long.valueOf(meterStatus.getCode())) .addValue("code", meterStatus.getCode()).addValue("status", meterStatus.getMeterStatus()) .addValue("active", meterStatus.getActive()) .addValue("description", meterStatus.getDescription()) .addValue("createdby", meterStatusRequest.getRequestInfo().getUserInfo().getId()) .addValue("createddate", new Date().getTime()) .addValue("lastmodifiedby", meterStatusRequest.getRequestInfo().getUserInfo().getId()) .addValue("lastmodifieddate", new Date().getTime()).addValue("tenantId", meterStatus.getTenantId()) .getValues()); namedParameterJdbcTemplate.batchUpdate(meterStatusQueryBuilder.getCreateMeterStatusQuery(), batchValues.toArray(new Map[meterStatuses.size()])); return meterStatusRequest; } List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq); MeterStatusReq create(final MeterStatusReq meterStatusRequest); List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest); MeterStatusReq update(final MeterStatusReq meterStatusRequest); List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_persist_createMeterStatus_to_db() { final MeterStatusReq meterStatusRequest = meterStatusRepository.create(getMeterStatusRequest()); assertThat(meterStatusRequest.getMeterStatus().size()).isEqualTo(2); }
|
### Question:
MeterStatusRepository { public MeterStatusReq update(final MeterStatusReq meterStatusRequest) { final List<MeterStatus> meterStatuses = meterStatusRequest.getMeterStatus(); final List<Map<String, Object>> batchValues = new ArrayList<>(meterStatuses.size()); for (final MeterStatus meterStatus : meterStatuses) batchValues.add(new MapSqlParameterSource("status", meterStatus.getMeterStatus()) .addValue("active", meterStatus.getActive()) .addValue("description", meterStatus.getDescription()) .addValue("lastmodifiedby", meterStatusRequest.getRequestInfo().getUserInfo().getId()) .addValue("lastmodifieddate", new Date().getTime()).addValue("code", meterStatus.getCode()) .addValue("tenantId", meterStatus.getTenantId()).getValues()); namedParameterJdbcTemplate.batchUpdate(meterStatusQueryBuilder.getUpdateMeterStatusQuery(), batchValues.toArray(new Map[meterStatuses.size()])); return meterStatusRequest; } List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq); MeterStatusReq create(final MeterStatusReq meterStatusRequest); List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest); MeterStatusReq update(final MeterStatusReq meterStatusRequest); List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest); static final Logger logger; }### Answer:
@Test public void test_should_persist_updateMeterStatus_to_db() { final MeterStatusReq meterStatusRequest = meterStatusRepository.update(getMeterStatusRequestForUpdate()); assertThat(meterStatusRequest.getMeterStatus().size()).isEqualTo(2); }
|
### Question:
MeterStatusRepository { public List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest) { final Map<String, Object> preparedStatementValues = new HashMap<>(); final String queryString = meterStatusQueryBuilder.getQuery(meterStatusGetRequest, preparedStatementValues); return namedParameterJdbcTemplate.query(queryString, preparedStatementValues, meterStatusRowMapper); } List<MeterStatus> pushCreateToQueue(final MeterStatusReq meterStatusReq); MeterStatusReq create(final MeterStatusReq meterStatusRequest); List<MeterStatus> pushUpdateToQueue(final MeterStatusReq meterStatusRequest); MeterStatusReq update(final MeterStatusReq meterStatusRequest); List<MeterStatus> getMeterStatusByCriteria(final MeterStatusGetRequest meterStatusGetRequest); static final Logger logger; }### Answer:
@SuppressWarnings("unchecked") @Test public void test_should_search_meterStatus() { final Map<String, Object> preparedStatementValues = new HashMap<>(); when(meterStatusQueryBuilder.getQuery(getMeterStatusGetRequest(), preparedStatementValues)) .thenReturn("Select ms.id as ms_id,ms.code as ms_code," + "ms.status as ms_status,ms.description as ms_description,ms.createdby as" + " ms_createdby,ms.createddate as ms_createddate,ms.lastmodifiedby as ms_" + "lastmodifiedby,ms.lastmodifieddate as ms_lastmodifieddate,ms.tenantid as" + " ms_tenantid FROM egwtr_meterstatus ms WHERE ms.tenantId = ? AND " + "ms.id IN (1, 2) ORDER BY status desc"); when(namedParameterJdbcTemplate.query(any(String.class), anyMap(), any(MeterStatusRowMapper.class))) .thenReturn(getListOfMeterStatuses()); assertTrue(getListOfMeterStatuses().equals(meterStatusRepository.getMeterStatusByCriteria(getMeterStatusGetRequest()))); }
|
### Question:
ServiceChargeDetailsRowMapper implements RowMapper<ServiceChargeDetails> { @Override public ServiceChargeDetails mapRow(final ResultSet rs, final int rowNum) throws SQLException { final ServiceChargeDetails serviceChargeDetail = new ServiceChargeDetails(); serviceChargeDetail.setId((Long) rs.getObject("scd_id")); serviceChargeDetail.setCode(rs.getString("scd_code")); serviceChargeDetail.setUomFrom((Double) rs.getObject("scd_uomfrom")); serviceChargeDetail.setUomTo((Double) rs.getObject("scd_uomto")); serviceChargeDetail.setAmountOrpercentage((Double) rs.getObject("scd_amountorpercentage")); serviceChargeDetail.setServiceCharge((Long) rs.getObject("scd_servicecharge")); serviceChargeDetail.setTenantId(rs.getString("scd_tenantid")); return serviceChargeDetail; } @Override ServiceChargeDetails mapRow(final ResultSet rs, final int rowNum); }### Answer:
@Test public void test_should_map_result_set_to_entity() throws Exception { Mockito.when(rs.next()).thenReturn(true).thenReturn(false); when((Long) rs.getObject("scd_id")).thenReturn(1L); when(rs.getString("scd_code")).thenReturn("1"); when((Double) rs.getObject("scd_uomfrom")).thenReturn(0.0); when((Double) rs.getObject("scd_uomto")).thenReturn(1000.0); when((Double) rs.getObject("scd_amountorpercentage")).thenReturn(100.0); when((Long) rs.getObject("scd_servicecharge")).thenReturn(1L); when(rs.getString("scd_tenantid")).thenReturn("default"); final ServiceChargeDetails expectedserviceChargeDetails = getServiceChargeDetails(); final ServiceChargeDetails actualserviceChargeDetails = serviceChargeDetailsRowMapper.mapRow(rs, 1); assertTrue(expectedserviceChargeDetails.equals(actualserviceChargeDetails)); }
|
### Question:
DonationRepository { public List<Donation> findForCriteria(final DonationGetRequest donationRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = donationQueryBuilder.getQuery(donationRequest, preparedStatementValues); final List<Donation> donationList = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), donationRowMapper); return donationList; } DonationRequest create(final DonationRequest donationRequest); DonationRequest update(final DonationRequest donationRequest); List<Donation> findForCriteria(final DonationGetRequest donationRequest); boolean checkDonationsExist(final String code, final String usageType,
final String subUsageType, final Double maxPipeSize, final Double minPipeSize,
final String tenantId); boolean checkPipeSizeExists(final Double pipeSize, final String tenantId); boolean checkUsageExists(final String usage, final String tenantId); }### Answer:
@Test public void test_Should_Find_Donation_Valid() { final List<Object> preparedStatementValues = new ArrayList<>(); final DonationGetRequest donationRequest = getDonationvalidaRequest(); final String queryString = "MyQuery"; final List<Donation> donations = new ArrayList<>(); when(jdbcTemplate.query(queryString, preparedStatementValues.toArray(), donationRowMapper)) .thenReturn(donations); assertTrue(donations.equals(donationRepository.findForCriteria(donationRequest))); }
|
### Question:
DocumentTypeRepository { public List<DocumentType> findForCriteria(final DocumentTypeGetReq documentTypeGetRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = documentTypeQueryBuilder.getQuery(documentTypeGetRequest, preparedStatementValues); final List<DocumentType> documentTypes = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), documentTypeRowMapper); return documentTypes; } DocumentTypeReq create(final DocumentTypeReq documentTypeReq); DocumentTypeReq update(final DocumentTypeReq documentTypeReq); boolean checkDocumentTypeByNameAndCode(final String code, final String name, final String tenantId); List<DocumentType> findForCriteria(final DocumentTypeGetReq documentTypeGetRequest); List<Long> getMandatoryocs(final String applicationType); }### Answer:
@Test public void test_Should_Find_DocumentType_Valid() { final List<Object> preparedStatementValues = new ArrayList<>(); final DocumentTypeGetReq docTypeGetRequest = Mockito.mock(DocumentTypeGetReq.class); final String queryString = "MyQuery"; when(docTypeQueryBuilder.getQuery(docTypeGetRequest, preparedStatementValues)).thenReturn(queryString); final List<DocumentType> docTypes = new ArrayList<>(); when(jdbcTemplate.query(queryString, preparedStatementValues.toArray(), docTypeRowMapper)) .thenReturn(docTypes); assertTrue( docTypes.equals(docTypeRepository.findForCriteria(docTypeGetRequest))); }
@Test(expected = Exception.class) public void test_throwException__FindforCriteria() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); final DocumentTypeGetReq docTypeGetRequest = new DocumentTypeGetReq(); when(docTypeQueryBuilder.getQuery(docTypeGetRequest, preparedStatementValues)).thenThrow(Exception.class); final List<DocumentType> docTypes = docTypeRepository.findForCriteria(docTypeGetRequest); assertTrue(docTypes != null); }
|
### Question:
ReceivingCenterTypeService { public ReceivingCenterTypeReq create(final ReceivingCenterTypeReq centerTypeReq) { return receivingCenterRepository.persistReceivingCenterType(centerTypeReq); } ReceivingCenterTypeReq create(final ReceivingCenterTypeReq centerTypeReq); ReceivingCenterTypeReq update(final ReceivingCenterTypeReq centerTypeReq); List<ReceivingCenterType> getAllReceivingCenterTypes(final ReceivingCenterTypeGetReq centerTypeGetRequest); boolean checkReceivingCenterTypeByCode(final String code, final String tenantId); boolean checkReceivingCenterNameExists(ReceivingCenterType receivingCenter, String mode); boolean checkReceivingCenterCodeName(final String code, final String name, final String tenantId, final String mode); ReceivingCenterType sendMessage(String topic, String key, final ReceivingCenterTypeReq centerTypeRequest); static final Logger logger; }### Answer:
@Test public void test_Should_ReceivingCenterType_Create() { final ReceivingCenterType receivingCenterType = getReceivingCenterType(); final List<ReceivingCenterType> receivingCenterTypes = new ArrayList<>(); receivingCenterTypes.add(receivingCenterType); final ReceivingCenterTypeReq receivingCenterTypeReq = new ReceivingCenterTypeReq(); receivingCenterTypeReq.setCenterType(receivingCenterType); final ReceivingCenterTypeRes propUsageTypeResponse = new ReceivingCenterTypeRes(); propUsageTypeResponse.setResponseInfo(null); propUsageTypeResponse.setCenterTypes(receivingCenterTypes); when(receivingCenterTypeService.create(any(ReceivingCenterTypeReq.class))).thenReturn(receivingCenterTypeReq); assertTrue(receivingCenterTypeReq.equals(receivingCenterTypeService.create(receivingCenterTypeReq))); }
|
### Question:
ReportService { public ResponseEntity<?> getFailureResponse( final RequestInfo requestInfo, String tenantID) { final MetadataResponse metadataResponses = new MetadataResponse(); final ResponseInfo responseInfo = responseInfoFactory.createResponseInfoFromRequestInfo(requestInfo, false); responseInfo.setResMsgId("Report Definition not found"); metadataResponses.setRequestInfo(responseInfo); metadataResponses.setTenantId(tenantID); return new ResponseEntity<>(metadataResponses, HttpStatus.NOT_FOUND); } MetadataResponse getMetaData(MetaDataRequest metaDataRequest, String moduleName); ResponseEntity<?> getSuccessResponse(final MetadataResponse metadataResponse, final RequestInfo requestInfo,
String tenantID); ResponseEntity<?> getReportDataSuccessResponse(final List<ReportResponse> reportResponse, final RequestInfo requestInfo
,String tenantId); ResponseEntity<?> getFailureResponse( final RequestInfo requestInfo,
String tenantID); ResponseEntity<?> getFailureResponse( final RequestInfo requestInfo,
String tenantID, Exception e); ResponseEntity<?> reloadResponse( final RequestInfo requestInfo, Exception e); List<ReportResponse> getAllReportData(ReportRequest reportRequest,String moduleName,String authToken); ReportResponse getReportData(ReportRequest reportRequest,String moduleName,String reportName,String authToken); static final Logger LOGGER; }### Answer:
@Test public void testGetFailureResponse() { }
|
### Question:
StorageReservoirRepository { public List<StorageReservoir> findForCriteria(final StorageReservoirGetRequest storageReservoirGetRequest) { final Map<String, Object> preparedStatementValues = new HashMap<>(); final String queryStr = storageReservoirQueryBuilder.getQuery(storageReservoirGetRequest, preparedStatementValues); final List<StorageReservoir> storageReservoirList = namedParameterJdbcTemplate.query(queryStr, preparedStatementValues, storageReservoirRowMapper); return storageReservoirList; } StorageReservoirRequest create(
final StorageReservoirRequest storageReservoirRequest); StorageReservoirRequest update(
final StorageReservoirRequest storageReservoirRequest); List<StorageReservoir> findForCriteria(final StorageReservoirGetRequest storageReservoirGetRequest); boolean checkStorageReservoirByNameAndCode(final String code, final String name, final String tenantId); }### Answer:
@Test public void test_Should_Search_StorageReservoir() { new ArrayList<>(); final List<StorageReservoir> storageReservoirList = new ArrayList<>(); final StorageReservoir storageReservoir = getStorageReservoir(); storageReservoirList.add(storageReservoir); final StorageReservoirGetRequest storageReservoirGetRequest = getStorageReservoirGetCriteria(); when(namedParameterJdbcTemplate.query(any(String.class), anyMap(), any(StorageReservoirRowMapper.class))) .thenReturn(storageReservoirList); assertTrue(storageReservoirRepository.findForCriteria(storageReservoirGetRequest).get(0).getCode() .equals(storageReservoirList.get(0).getCode())); }
|
### Question:
UsageTypeRepository { public List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest) { final List<UsageType> usageTypes = usageTypeRequest.getUsageTypes(); for (final UsageType usageType : usageTypes) usageType.setCode(codeSequenceNumberGenerator.getNextSequence(UsageType.SEQ_USAGE_TYPE).toString()); logger.info("Sending UsageType request to kafka Queue:" + usageTypeRequest); try { kafkaTemplate.send(applicationProperties.getCreateUsageTypeTopicName(), usageTypeRequest); } catch (final Exception e) { logger.error("Exception encountered:" + e); } return usageTypeRequest.getUsageTypes(); } List<UsageType> getUsageTypesByCriteria(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq update(final UsageTypeReq usageTypeRequest); static final Logger logger; }### Answer:
@Test public void test_should_push_create_usageType_to_queue() { when(codeSequenceNumberGenerator.getNextSequence("SEQ_EGWTR_USAGE_TYPE")).thenReturn("1", "2"); when(applicationProperties.getCreateUsageTypeTopicName()).thenReturn("egov.wcms.usagetype-create"); usageTypeRepository.pushCreateToQueue(getUsageTypeRequest()); verify(kafkaTemplate).send("egov.wcms.usagetype-create", getUsageTypeRequest()); }
|
### Question:
UsageTypeRepository { public List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest) { logger.info("Sending UsageType request to kafka Queue:" + usageTypeRequest); try { kafkaTemplate.send(applicationProperties.getUpdateUsageTypeTopicName(), usageTypeRequest); } catch (final Exception e) { logger.error("Exception encountered:" + e); } return usageTypeRequest.getUsageTypes(); } List<UsageType> getUsageTypesByCriteria(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq update(final UsageTypeReq usageTypeRequest); static final Logger logger; }### Answer:
@Test public void test_should_push_update_usageType_to_queue() { when(codeSequenceNumberGenerator.getNextSequence("SEQ_EGWTR_USAGE_TYPE")).thenReturn("1", "2"); when(applicationProperties.getUpdateUsageTypeTopicName()).thenReturn("egov.wcms.usagetype-update"); usageTypeRepository.pushUpdateToQueue(getUsageTypeRequestForUpdate()); verify(kafkaTemplate).send("egov.wcms.usagetype-update", getUsageTypeRequestForUpdate()); }
|
### Question:
UsageTypeRepository { @SuppressWarnings("unchecked") public UsageTypeReq update(final UsageTypeReq usageTypeRequest) { final List<UsageType> usageTypes = usageTypeRequest.getUsageTypes(); final String usageTypeUpdateQuery = usageTypeQueryBuilder.getUpdateUsageTypeQuery(); final List<Map<String, Object>> usageTypeQueryParams = new ArrayList<>(); for (final UsageType usageType : usageTypes) usageTypeQueryParams.add(new MapSqlParameterSource("name", usageType.getName()) .addValue("description", usageType.getDescription()).addValue("parent", usageType.getParent()) .addValue("active", usageType.getActive()) .addValue("lastmodifiedby", usageTypeRequest.getRequestInfo().getUserInfo().getId()) .addValue("lastmodifieddate", new Date().getTime()).addValue("code", usageType.getCode()) .addValue("tenantid", usageType.getTenantId()).getValues()); try { namedParameterJdbcTemplate.batchUpdate(usageTypeUpdateQuery, usageTypeQueryParams.toArray(new Map[usageTypes.size()])); } catch (final Exception e) { logger.error("Error occured while updating usageType in db" + e); } return usageTypeRequest; } List<UsageType> getUsageTypesByCriteria(final UsageTypeGetRequest usageTypeGetRequest); List<UsageType> pushCreateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq create(final UsageTypeReq usageTypeRequest); List<UsageType> pushUpdateToQueue(final UsageTypeReq usageTypeRequest); @SuppressWarnings("unchecked") UsageTypeReq update(final UsageTypeReq usageTypeRequest); static final Logger logger; }### Answer:
@Test public void test_should_persist_update_usageType_to_DB() { final UsageTypeReq usageTypeReq = usageTypeRepository.update(getUsageTypeRequestForUpdate()); assertThat(usageTypeReq.getUsageTypes().size()).isEqualTo(2); }
|
### Question:
UsageTypeQueryBuilder { public String getQuery(final UsageTypeGetRequest usageTypeGetRequest, final Map<String, Object> preparedStatementValues) { final StringBuilder selectQuery; if (!usageTypeGetRequest.getIsSubUsageType()) selectQuery = new StringBuilder(BASE_USAGE_QUERY); else selectQuery = new StringBuilder(BASE_SUBUSAGE_QUERY); addWhereClause(usageTypeGetRequest, preparedStatementValues, selectQuery); addOrderByClause(usageTypeGetRequest, selectQuery); return selectQuery.toString(); } String getQuery(final UsageTypeGetRequest usageTypeGetRequest,
final Map<String, Object> preparedStatementValues); String getUsageTypeInsertQuery(); String getUpdateUsageTypeQuery(); String getUsageTypeIdQuery(); String getUsageTypeIdQueryWithCode(); static final String BASE_USAGE_QUERY; static final String BASE_SUBUSAGE_QUERY; }### Answer:
@Test public void no_input_test() { final UsageTypeQueryBuilder usageTypeQueryBuilder = new UsageTypeQueryBuilder(); final UsageTypeGetRequest usageTypeGetRequest = new UsageTypeGetRequest(); final Map<String, Object> preparedStatementValues = new HashMap<>(); assertEquals("Select ut.id as ut_id,ut.code as ut_code,ut.name " + "as ut_name,ut.description as ut_description," + "ut.active as ut_active,ut.parent as ut_parent,ut.tenantid as ut_tenantid," + "ut.createdby as ut_createdby,ut.createddate as ut_createddate,ut.lastmodifiedby" + " as ut_lastmodifiedby,ut.lastmodifieddate as ut_lastmodifieddate from" + " egwtr_usage_type ut ORDER BY ut.id DESC", usageTypeQueryBuilder.getQuery(usageTypeGetRequest, preparedStatementValues)); }
|
### Question:
GapcodeRepository { public List<Gapcode> findForCriteria( final GapcodeGetRequest gapcodeGetRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = gapcodeQueryBuilder.getQuery(gapcodeGetRequest, preparedStatementValues); log.info(queryStr); final List<Gapcode> gapcode = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), gapcodeRowMapper); return gapcode; } GapcodeRequest create(final GapcodeRequest gapcodeRequest); GapcodeRequest update(final GapcodeRequest gapcodeRequest); List<Gapcode> findForCriteria(
final GapcodeGetRequest gapcodeGetRequest); List<CommonDataModel> getFormulaQuery(); }### Answer:
@Test public void test_Should_Find_CategoryType_Valid() { final List<Object> preparedStatementValues = new ArrayList<>(); final GapcodeGetRequest gapcodeGetRequest = Mockito .mock(GapcodeGetRequest.class); final String queryString = "MyQuery"; when( gapcodeQueryBuilder.getQuery(gapcodeGetRequest, preparedStatementValues)).thenReturn(queryString); final List<Gapcode> connectionCategories = new ArrayList<>(); when( jdbcTemplate.query(queryString, preparedStatementValues.toArray(), gapcodeRowMapper)) .thenReturn(connectionCategories); assertTrue(connectionCategories.equals(gapcodeRepository .findForCriteria(gapcodeGetRequest))); }
|
### Question:
SourceTypeRepository { public List<SourceType> findForCriteria(final SourceTypeGetRequest sourceTypeGetRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = sourceTypeQueryBuilder.getQuery(sourceTypeGetRequest, preparedStatementValues); final List<SourceType> waterSourceTypes = jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), sourceTypeRowMapper); return waterSourceTypes; } SourceTypeRequest create(final SourceTypeRequest sourceTypeRequest); SourceTypeRequest update(final SourceTypeRequest sourceTypeRequest); boolean checkWaterSourceTypeByNameAndCode(final String code, final String name, final String tenantId); List<SourceType> findForCriteria(final SourceTypeGetRequest sourceTypeGetRequest); }### Answer:
@Test public void test_Should_Search_WaterSource() { final List<SourceType> waterSourceTypes = new ArrayList<>(); final SourceType waterSource = getWaterSourceType(); waterSourceTypes.add(waterSource); when(waterSourceTypeQueryBuilder.getQuery(any(SourceTypeGetRequest.class), any(List.class))).thenReturn(""); when(jdbcTemplate.query(any(String.class), any(Object[].class), any(SourceTypeRowMapper.class))) .thenReturn(waterSourceTypes); assertTrue(waterSourceTypes.equals(waterSourceTypeRepository.findForCriteria(new SourceTypeGetRequest()))); }
@Test public void test_Inavalid_Find_WaterSource() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); final List<SourceType> waterSourceTypes = new ArrayList<>(); final SourceType waterSource = getWaterSourceType(); waterSourceTypes.add(waterSource); final SourceTypeGetRequest waterSourceGetRequest = Mockito.mock(SourceTypeGetRequest.class); when(waterSourceTypeQueryBuilder.getQuery(waterSourceGetRequest, preparedStatementValues)).thenReturn(null); when(jdbcTemplate.query("query", preparedStatementValues.toArray(), waterSourceTypeRowMapper)) .thenReturn(waterSourceTypes); assertTrue(!waterSourceTypes.equals(waterSourceTypeRepository.findForCriteria(waterSourceGetRequest))); }
|
### Question:
SupplyTypeRepository { public SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest) { final String updateQuery = SupplyTypeQueryBuilder.updateSupplyTypeQuery(); final List<SupplyType> supplyTypeList = supplyTypeRequest.getSupplyTypes(); final List<Map<String, Object>> batchValues = new ArrayList<>(supplyTypeList.size()); for (final SupplyType supplyType : supplyTypeList) batchValues.add( new MapSqlParameterSource("name", supplyType.getName()) .addValue("description", supplyType.getDescription()).addValue("active", supplyType.getActive()) .addValue("lastmodifiedby", Long.valueOf(supplyTypeRequest.getRequestInfo().getUserInfo().getId())) .addValue("lastmodifieddate", new Date(new java.util.Date().getTime())) .addValue("code", supplyType.getCode()) .addValue("tenantid", supplyType.getTenantId()) .getValues()); namedParameterJdbcTemplate.batchUpdate(updateQuery, batchValues.toArray(new Map[supplyTypeList.size()])); return supplyTypeRequest; } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); boolean checkSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> findForCriteria(final SupplyTypeGetRequest supplyTypeGetRequest); }### Answer:
@Test public void test_Should_Update_WaterSource() { final SupplyTypeRequest waterSourceTypeRequest = new SupplyTypeRequest(); final RequestInfo requestInfo = new RequestInfo(); final User user = new User(); user.setId(1l); requestInfo.setUserInfo(user); waterSourceTypeRequest.setRequestInfo(requestInfo); final List<SupplyType> waterSourceList = new ArrayList<>(); waterSourceList.add(getSupplyType()); waterSourceTypeRequest.setSupplyTypes(waterSourceList); when(jdbcTemplate.update(any(String.class), any(Object[].class))).thenReturn(1); assertTrue(waterSourceTypeRequest .equals(supplyTypeRepository.update(waterSourceTypeRequest))); }
|
### Question:
SupplyTypeRepository { public List<SupplyType> findForCriteria(final SupplyTypeGetRequest supplyTypeGetRequest) { final List<Object> preparedStatementValues = new ArrayList<>(); final String queryStr = supplyTypeQueryBuilder.getQuery(supplyTypeGetRequest, preparedStatementValues); return jdbcTemplate.query(queryStr, preparedStatementValues.toArray(), supplyTypeRowMapper); } SupplyTypeRequest create(final SupplyTypeRequest supplyTypeRequest); SupplyTypeRequest update(final SupplyTypeRequest supplyTypeRequest); boolean checkSupplyTypeByNameAndCode(final String code, final String name, final String tenantId); List<SupplyType> findForCriteria(final SupplyTypeGetRequest supplyTypeGetRequest); }### Answer:
@Test public void test_Should_Search_WaterSource() { final List<SupplyType> supplyTypes = new ArrayList<>(); final SupplyType supplyType = getSupplyType(); supplyTypes.add(supplyType); when(supplyTypeQueryBuilder.getQuery(any(SupplyTypeGetRequest.class), any(List.class))).thenReturn(""); when(jdbcTemplate.query(any(String.class), any(Object[].class), any(SupplyTypeRowMapper.class))) .thenReturn(supplyTypes); assertTrue(supplyTypes.equals(supplyTypeRepository.findForCriteria(new SupplyTypeGetRequest()))); }
@Test public void test_Inavalid_Find_WaterSource() throws Exception { final List<Object> preparedStatementValues = new ArrayList<>(); final List<SupplyType> supplyTypes = new ArrayList<>(); final SupplyType waterSource = getSupplyType(); supplyTypes.add(waterSource); final SupplyTypeGetRequest waterSourceGetRequest = Mockito.mock(SupplyTypeGetRequest.class); when(supplyTypeQueryBuilder.getQuery(waterSourceGetRequest, preparedStatementValues)).thenReturn(null); when(jdbcTemplate.query("query", preparedStatementValues.toArray(), supplyTypeRowMapper)) .thenReturn(supplyTypes); assertTrue(!supplyTypes.equals(supplyTypeRepository.findForCriteria(waterSourceGetRequest))); }
|
### Question:
AgreementCriteria { public boolean isAgreementEmpty() { return Stream.of(agreementId, agreementNumber, status, fromDate, toDate, tenderNumber, tinNumber, tradelicenseNumber, asset, allottee, referenceNumber, oldAgreementNumber, floorNumber) .allMatch(Objects::isNull); } Long getId(); void setId(Long id); boolean isAgreementEmpty(); boolean isAllotteeEmpty(); boolean isAssetEmpty(); boolean isAssetOnlyNull(); boolean isAllotteeOnlyNull(); boolean isAgreementOnlyNull(); boolean isAgreementAndAllotteeNull(); boolean isAssetAndAllotteeNull(); boolean isAgreementAndAssetNull(); boolean isAgreementAndAssetAndAllotteeNotNull(); }### Answer:
@Test public void test_for_is_agreement_not_null(){ boolean isAgreementNull = agreementCriteria.isAgreementEmpty(); assertEquals(isAgreementNull, false); }
@Test public void test_for_is_agreement_null(){ agreementCriteria = getEmptyAgreementCriteria(); boolean isAgreementNull = agreementCriteria.isAgreementEmpty(); assertEquals(isAgreementNull, true); }
|
### Question:
AgreementCriteria { public boolean isAllotteeEmpty() { return Stream.of(allotteeName, mobileNumber) .allMatch(Objects::isNull); } Long getId(); void setId(Long id); boolean isAgreementEmpty(); boolean isAllotteeEmpty(); boolean isAssetEmpty(); boolean isAssetOnlyNull(); boolean isAllotteeOnlyNull(); boolean isAgreementOnlyNull(); boolean isAgreementAndAllotteeNull(); boolean isAssetAndAllotteeNull(); boolean isAgreementAndAssetNull(); boolean isAgreementAndAssetAndAllotteeNotNull(); }### Answer:
@Test public void test_if_allottee_not_present(){ agreementCriteria = getEmptyAgreementCriteria(); boolean isAllootteePresent = agreementCriteria.isAllotteeEmpty(); assertEquals(isAllootteePresent, true); }
@Test public void test_if_allottee_present(){ boolean isAllootteePresent = agreementCriteria.isAllotteeEmpty(); assertEquals(isAllootteePresent, false); }
|
### Question:
AgreementCriteria { public boolean isAssetEmpty() { return Stream.of(assetCategory, shoppingComplexName, assetCode, locality, revenueWard, electionWard, shopNumber) .allMatch(Objects::isNull); } Long getId(); void setId(Long id); boolean isAgreementEmpty(); boolean isAllotteeEmpty(); boolean isAssetEmpty(); boolean isAssetOnlyNull(); boolean isAllotteeOnlyNull(); boolean isAgreementOnlyNull(); boolean isAgreementAndAllotteeNull(); boolean isAssetAndAllotteeNull(); boolean isAgreementAndAssetNull(); boolean isAgreementAndAssetAndAllotteeNotNull(); }### Answer:
@Test public void test_for_asset_not_empty(){ boolean isAssetNull = agreementCriteria.isAssetEmpty(); assertEquals(isAssetNull, false); }
@Test public void test_to_check_for_empty_asset(){ agreementCriteria = getEmptyAgreementCriteria(); boolean isAssetNull = agreementCriteria.isAssetEmpty(); assertEquals(isAssetNull, true); }
|
### Question:
ReceivingCenterTypeService { public ReceivingCenterTypeReq update(final ReceivingCenterTypeReq centerTypeReq) { return receivingCenterRepository.persistModifyReceivingCenterType(centerTypeReq); } ReceivingCenterTypeReq create(final ReceivingCenterTypeReq centerTypeReq); ReceivingCenterTypeReq update(final ReceivingCenterTypeReq centerTypeReq); List<ReceivingCenterType> getAllReceivingCenterTypes(final ReceivingCenterTypeGetReq centerTypeGetRequest); boolean checkReceivingCenterTypeByCode(final String code, final String tenantId); boolean checkReceivingCenterNameExists(ReceivingCenterType receivingCenter, String mode); boolean checkReceivingCenterCodeName(final String code, final String name, final String tenantId, final String mode); ReceivingCenterType sendMessage(String topic, String key, final ReceivingCenterTypeReq centerTypeRequest); static final Logger logger; }### Answer:
@Test public void test_Should_Update_ReceivingCenterType() { final ReceivingCenterType receivingCenterType = getReceivingCenterType(); final List<ReceivingCenterType> receivingCenterTypes = new ArrayList<>(); receivingCenterTypes.add(receivingCenterType); final ReceivingCenterTypeReq receivingCenterTypeRequest = new ReceivingCenterTypeReq(); receivingCenterTypeRequest.setCenterType(receivingCenterType); final ReceivingCenterTypeRes receivingCenterTypeResponse = new ReceivingCenterTypeRes(); receivingCenterTypeResponse.setResponseInfo(null); receivingCenterTypeResponse.setCenterTypes(receivingCenterTypes); when(receivingCenterTypeService.update(any(ReceivingCenterTypeReq.class))).thenReturn(receivingCenterTypeRequest); assertTrue(receivingCenterTypeRequest.equals(receivingCenterTypeService.update(receivingCenterTypeRequest))); }
|
### Question:
DocumentTypeService { public List<DocumentType> getDocumentTypes(DocumentType documentType) { return documentTypeRepository.getDocumentTypes(documentType); } List<DocumentType> getDocumentTypes(DocumentType documentType); }### Answer:
@Test public void getDocumentTypesTest() { List<DocumentType> documentTypes = new ArrayList<>(); DocumentType documentType = new DocumentType(); documentType.setId(1l); when(documentTypeRepository.getDocumentTypes(any(DocumentType.class))).thenReturn(documentTypes); assertTrue(documentTypes.equals(documentTypeService.getDocumentTypes(any(DocumentType.class)))); }
|
### Question:
LamsConfigurationService { public Map<String, List<String>> getLamsConfigurations(LamsConfigurationGetRequest lamsConfigurationGetRequest) { return lamsConfigurationRepository.findForCriteria(lamsConfigurationGetRequest); } Map<String, List<String>> getLamsConfigurations(LamsConfigurationGetRequest lamsConfigurationGetRequest); }### Answer:
@Test public void getLamsConfigurationTest(){ Map<String, List<String>> map = new HashMap<>(); List<String> list = new ArrayList<>(); list.add("value"); map.put("key",list); when(lamsConfigurationRepository.findForCriteria(any(LamsConfigurationGetRequest.class))).thenReturn(map); assertTrue(map.equals(lamsConfigurationService.getLamsConfigurations(any(LamsConfigurationGetRequest.class)))); }
|
### Question:
NoticeRepository { public List<Notice> getNotices(NoticeCriteria noticeCriteria) { List<Notice> notices = null; Map<String, Object> params = new HashMap<>(); String queryString = NoticeQueryBuilder.getNoticeQuery(noticeCriteria, params); try { notices = namedParameterJdbcTemplate.query(queryString, params, new NoticeRowMapper()); } catch (DataAccessException e) { LOGGER.info("the exception from notice repo query :: " + e); throw new RuntimeException(e.getMessage()); } return notices; } Notice createNotice(NoticeRequest noticeRequest); DueNotice createDueNotice(DueNoticeRequest noticeRequest); List<DueNotice> getAllDueNoticesByAgreement(DueNoticeCriteria noticeCriteria); Set<DefaultersInfo> generateDueNoticeData(DueSearchCriteria dueCriteria); List<Notice> getNotices(NoticeCriteria noticeCriteria); List<DefaultersInfo> getDefaulterDetails(DueNotice noticeData); static final Logger LOGGER; }### Answer:
@Test public void getNoticesTest(){ }
|
### Question:
AgreementMessageQueueRepository { public void save(AgreementRequest agreementRequest, String action) { try { Agreement agreement = agreementRequest.getAgreement(); logger.info("agreement before sending" + agreement); kafkaTemplate.send(getTopicName(action), KEY, agreementRequest); } catch (Exception exception) { logger.info("AgreementService : " + exception.getMessage(), exception); throw exception; } } AgreementMessageQueueRepository(LogAwareKafkaTemplate<String, Object> kafkaTemplate,
@Value("${kafka.topics.start.workflow}") String startWorkflowTopic,
@Value("${kafka.topics.update.workflow}") String updateWorkflowTopic,
@Value("${kafka.topics.save.agreement}") String saveTopic,
@Value("${kafka.topics.update.agreement}") String updateTopic); void save(AgreementRequest agreementRequest, String action); static final Logger logger; static final String KEY; static final String START_WORKFLOW; static final String UPDATE_WORKFLOW; static final String SAVE; static final String UPDATE; }### Answer:
@Test public void test_to_send_message_to_Kafka(){ agreementMessageQueueRepository.save(getAgreementRequest(), UPDATE); verify(kafkaTemplate).send(any(), any(), any()); }
|
### Question:
PositionRestRepository { public PositionResponse getPositions(String allotteeId, String tenantId, RequestInfoWrapper requestInfoWrapper){ String positionUrl = hostName + searchPath.replace(pathVariable, allotteeId) + "?tenantId=" + tenantId; logger.info("the request url to position get call :: " + positionUrl); logger.info("the request body to position get call :: " + requestInfoWrapper); try { PositionResponse positionResponse = restTemplate.postForObject(positionUrl, requestInfoWrapper, PositionResponse.class); logger.info("the response form position get call :: " + positionResponse); return positionResponse; } catch (Exception e) { logger.info("the exception from poisition search :: " + e); throw e; } } PositionRestRepository(RestTemplate restTemplate,
@Value("${egov.services.employee_service.hostname}") String hostName,
@Value("${egov.services.employee_service.searchpath}") String searchPath,
@Value("${egov.services.employee_service.searchpath.pathvariable}") String pathVariable); PositionResponse getPositions(String allotteeId, String tenantId, RequestInfoWrapper requestInfoWrapper); static final Logger logger; }### Answer:
@Test public void test_should_fetch_positions_of_employees(){ server.expect(once(), requestTo("http: .andExpect(method(HttpMethod.POST)) .andRespond(withSuccess(new Resources().getFileContents("positionResponse.json"), MediaType.APPLICATION_JSON_UTF8)); PositionResponse positionResponse = positionRestRepository.getPositions("1","ap.kurnool", new RequestInfoWrapper()); server.verify(); assertTrue(null != positionResponse); assertEquals(Long.valueOf(1l), positionResponse.getPosition().get(0).getId()); }
|
### Question:
BillRepository { public String createBillAndGetXml(List<BillInfo> billInfos, RequestInfo requestInfo) { BillRequest billRequest = new BillRequest(); billRequest.setRequestInfo(requestInfo); billRequest.setBillInfos(billInfos); String url = propertiesManager.getDemandServiceHostName() + propertiesManager.getDemandBillCreateService(); LOGGER.info("billRequest url ++++++++++++ " + url); BillResponse billResponse = restTemplate.postForObject(url, billRequest, BillResponse.class); LOGGER.info("billResponse>>>>>>>>>>" + billResponse.getBillXmls()); if (billResponse.getBillXmls().isEmpty()) { LOGGER.info("exception occured while getting billInfo"); throw new CollectionExceedException(); } else return billResponse.getBillXmls().get(0); } String createBillAndGetXml(List<BillInfo> billInfos, RequestInfo requestInfo); BillResponse updateBill(List<BillInfo> billInfos, RequestInfo requestInfo); BillInfo searchBill(BillSearchCriteria billSearchCriteria, RequestInfo requestInfo); Map getPurpose(String tenantId); }### Answer:
@Test public void createBillAndGetXmlTest() { RequestInfo requestInfo = new RequestInfo(); BillRequest billRequest = new BillRequest(); List<BillInfo> billInfos = getBillInfos(); billRequest.setRequestInfo(requestInfo); billRequest.setBillInfos(billInfos); BillResponse billResponse = new BillResponse(); String billXml = "billXml"; List<String> billXmls = new ArrayList<>(); billXmls.add(billXml); billResponse.setBillXmls(billXmls); String url = "host/_create"; when(propertiesManager.getDemandServiceHostName()).thenReturn("host/"); when(propertiesManager.getDemandBillCreateService()).thenReturn("_create"); when(restTemplate.postForObject(url, billRequest, BillResponse.class)).thenReturn(billResponse); assertTrue(billXml.equals(billRepository.createBillAndGetXml(billInfos, requestInfo))); }
|
### Question:
BillRepository { public BillInfo searchBill(BillSearchCriteria billSearchCriteria, RequestInfo requestInfo) { String url = propertiesManager.getDemandServiceHostName() + propertiesManager.getDemandBillSearchService() + "?billId=" + billSearchCriteria.getBillId(); LOGGER.info("The url for search bill API ::: " + url); BillResponse billResponse = null; if (requestInfo == null) { LOGGER.info("requestInfo ::: is null "); requestInfo = new RequestInfo(); requestInfo.setApiId("apiid"); requestInfo.setVer("ver"); requestInfo.setTs(new Date()); } try { billResponse = restTemplate.postForObject(url, requestInfo, BillResponse.class); } catch (Exception e) { e.printStackTrace(); LOGGER.info("the exception from billsearch API call ::: " + e); } LOGGER.info("the response for bill search API call ::: " + billResponse.getBillInfos().get(0)); return billResponse.getBillInfos().get(0); } String createBillAndGetXml(List<BillInfo> billInfos, RequestInfo requestInfo); BillResponse updateBill(List<BillInfo> billInfos, RequestInfo requestInfo); BillInfo searchBill(BillSearchCriteria billSearchCriteria, RequestInfo requestInfo); Map getPurpose(String tenantId); }### Answer:
@Test public void searchBillTest() { BillSearchCriteria billSearchCriteria = new BillSearchCriteria(); billSearchCriteria.setBillId(1l); RequestInfo requestInfo = new RequestInfo(); List<BillInfo> billInfos = getBillInfos(); BillResponse billResponse = new BillResponse(); billResponse.setBillInfos(billInfos); String url = "host/_search" + "?billId=" + billSearchCriteria.getBillId(); when(propertiesManager.getDemandServiceHostName()).thenReturn("host/"); when(propertiesManager.getDemandBillSearchService()).thenReturn("_search"); when(restTemplate.postForObject(url, requestInfo, BillResponse.class)).thenReturn(billResponse); assertTrue(billInfos.get(0).equals(billRepository.searchBill(billSearchCriteria, requestInfo))); }
|
### Question:
BillRepository { public Map getPurpose(String tenantId) { Map purpose = null; try { String url = applicationProperties.getHostNameForMonolith(tenantId) + propertiesManager.getPurposeService(); LOGGER.info("url>>>>>>>>>>" + url); purpose = restTemplate.getForObject(url, Map.class); } catch (RestClientException e) { e.printStackTrace(); } LOGGER.info("Purpose>>>>>>>>>>" + purpose); return purpose; } String createBillAndGetXml(List<BillInfo> billInfos, RequestInfo requestInfo); BillResponse updateBill(List<BillInfo> billInfos, RequestInfo requestInfo); BillInfo searchBill(BillSearchCriteria billSearchCriteria, RequestInfo requestInfo); Map getPurpose(String tenantId); }### Answer:
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void getPurposeTest() { String url = "host/service"; Map map = new HashMap<>(); map.put("map", "map"); when(propertiesManager.getPurposeService()).thenReturn("service"); when(restTemplate.getForObject(url, Map.class)).thenReturn(map); }
|
### Question:
ReceivingModeTypeService { public ReceivingModeTypeReq create(final ReceivingModeTypeReq modeTypeReq) { return receivingModeRepository.persistReceivingModeType(modeTypeReq); } ReceivingModeTypeReq create(final ReceivingModeTypeReq modeTypeReq); ReceivingModeTypeReq update(final ReceivingModeTypeReq modeTypeReq); List<ReceivingModeType> getAllReceivingModeTypes(final ReceivingModeTypeGetReq modeTypeGetRequest); boolean checkReceivingModeTypeByNameAndCode(final String code, final String name, final String tenantId, String mode); boolean checkReceivingModeTypeByName(final String code, final String name, final String tenantId, final String mode); boolean checkReceivingModeTypeByCode(final String code, final String tenantId, final String mode); ReceivingModeType sendMessage(String topic, String key, final ReceivingModeTypeReq modeTypeRequest); static final Logger logger; }### Answer:
@Test public void test_Should_ReceivingModeType_Create() { final ReceivingModeType receivingModeType = getReceivingModeType(); final List<ReceivingModeType> receivingModeTypes = new ArrayList<>(); receivingModeTypes.add(receivingModeType); final ReceivingModeTypeReq receivingModeTypeReq = new ReceivingModeTypeReq(); receivingModeTypeReq.setModeType(receivingModeType); final ReceivingModeTypeRes propUsageTypeResponse = new ReceivingModeTypeRes(); propUsageTypeResponse.setResponseInfo(null); propUsageTypeResponse.setModeTypes(receivingModeTypes); when(receivingModeTypeService.create(any(ReceivingModeTypeReq.class))).thenReturn(receivingModeTypeReq); assertTrue(receivingModeTypeReq.equals(receivingModeTypeService.create(receivingModeTypeReq))); }
|
### Question:
RentIncrementRepository { public List<RentIncrementType> getRentIncrements(String tenantId, String basisOfAllotment) { Map params = new HashMap(); String query = "select * from eglams_rentincrementtype rentincrement where rentincrement.tenant_id=:tenantId"; params.put("tenantId", tenantId); if(StringUtils.isNotBlank(basisOfAllotment)){ query = query.concat(" and rentincrement.type=:type "); params.put("type", basisOfAllotment); } List<RentIncrementType> rentIncrements = null; try { rentIncrements = namedParameterJdbcTemplate.query(query, params, new BeanPropertyRowMapper<>(RentIncrementType.class)); } catch (Exception ex) { logger.info(ex.getMessage(), ex); throw new RuntimeException("No records found for given criteria"); } return rentIncrements; } List<RentIncrementType> getRentIncrements(String tenantId, String basisOfAllotment); List<RentIncrementType> getRentIncrementById(Long rentID); static final Logger logger; }### Answer:
@Test public void getRentIncrementsTest() { List<RentIncrementType> rentIncrements = new ArrayList<>(); RentIncrementType rentIncrementType = new RentIncrementType(); rentIncrementType.setId(1l); rentIncrementType.setTenantId("1"); rentIncrements.add(rentIncrementType); when(namedParameterJdbcTemplate.query(any(String.class),any(Map.class), Matchers.<BeanPropertyRowMapper>any())).thenReturn(rentIncrements); assertTrue(rentIncrements.equals(rentIncrementRepository.getRentIncrements(rentIncrementType.getTenantId(), null))); }
|
### Question:
RentIncrementRepository { public List<RentIncrementType> getRentIncrementById(Long rentID) { String rentIncrementTypeqQuery = AgreementQueryBuilder.RENT_INCREMENT_TYPE_QUERY; Map params = new HashMap(); params.put("rentId", rentID); List<RentIncrementType> rentIncrements = null; try { rentIncrements = namedParameterJdbcTemplate.query(rentIncrementTypeqQuery, params, new BeanPropertyRowMapper<>(RentIncrementType.class)); } catch (Exception e) { logger.info(e.getMessage(), e); throw new RuntimeException(e.getMessage()); } return rentIncrements; } List<RentIncrementType> getRentIncrements(String tenantId, String basisOfAllotment); List<RentIncrementType> getRentIncrementById(Long rentID); static final Logger logger; }### Answer:
@Test public void getRentIncrementByIdTest() { List<RentIncrementType> rentIncrements = new ArrayList<>(); RentIncrementType rentIncrementType = new RentIncrementType(); rentIncrementType.setId(1l); Long rentId = 1l; rentIncrements.add(rentIncrementType); when(namedParameterJdbcTemplate.query(any(String.class), any(Map.class), Matchers.<BeanPropertyRowMapper>any())) .thenReturn(rentIncrements); assertTrue(rentIncrements.equals(rentIncrementRepository.getRentIncrementById(rentId))); }
|
### Question:
NoticeController { @PostMapping("_create") @ResponseBody public ResponseEntity<?> generateNotice(@RequestBody NoticeRequest noticeRequest, BindingResult errors) { LOGGER.info("NoticeController noticeRequest:" + noticeRequest); if (errors.hasErrors()) { ErrorResponse errRes = populateErrors(errors); return new ResponseEntity<>(errRes, HttpStatus.BAD_REQUEST); } NoticeResponse noticeResponse = noticeService.generateNotice(noticeRequest); return new ResponseEntity<>(noticeResponse, HttpStatus.CREATED); } @PostMapping("_create") @ResponseBody ResponseEntity<?> generateNotice(@RequestBody NoticeRequest noticeRequest, BindingResult errors); @PostMapping("_search") @ResponseBody ResponseEntity<?> search(@ModelAttribute @Valid NoticeCriteria noticeCriteria,
@RequestBody @Valid RequestInfo requestInfo, BindingResult errors); @PostMapping("_duenotice") @ResponseBody ResponseEntity<?> generateDueNotice(@ModelAttribute @Valid DueSearchCriteria dueCriteria,
@RequestBody @Valid RequestInfo requestInfo, BindingResult errors); @PostMapping("duenotice/_create") @ResponseBody ResponseEntity<?> createDueNotice(@RequestBody @Valid DueNoticeRequest dueNoticeRequest,
BindingResult errors); @PostMapping("duenotice/_search") @ResponseBody ResponseEntity<?> searchDueNotice(@ModelAttribute @Valid DueNoticeCriteria noticeCriteria,
@RequestBody @Valid RequestInfo requestInfo, BindingResult errors); static final Logger LOGGER; }### Answer:
@Test public void test_Should_Create_Notices() throws Exception{ NoticeResponse noticeResponse = new NoticeResponse(); noticeResponse.setResponseInfo(new ResponseInfo()); when(noticeService.generateNotice(any(NoticeRequest.class))).thenReturn(noticeResponse); mockMvc.perform(post("/agreement/notice/_create") .contentType(MediaType.APPLICATION_JSON) .content(getFileContents("noticerequest.json"))) .andExpect(status().isCreated()) .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) .andExpect(content().json(getFileContents("noticeresponse.json"))); }
|
### Question:
DesignationService { public List<Designation> getDesignations(DesignationGetRequest designationGetRequest) { return designationRepository.findForCriteria(designationGetRequest); } List<Designation> getDesignations(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); 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); 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); 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); 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:
DepartmentDesignationService { public DepartmentDesignation getDepartmentDesignation(Long id) { return departmentDesignationRepository.findForId(id); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(Long department, Long designation, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_getDepartmentDesignation() { DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentId(10L).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(Long department, Long designation, String tenantId) { return departmentDesignationRepository.findByDepartmentAndDesignation(department, designation, tenantId); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(Long department, Long designation, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_getByDepartmentAndDesignation(){ DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentId(10L).id(1L).tenantId("default").build(); when(departmentDesignationRepository.findByDepartmentAndDesignation(any(Long.class), any(Long.class), any(String.class))).thenReturn(departmentDesignation); DepartmentDesignation result = departmentDesignationService.getByDepartmentAndDesignation(10L, 1L, "default"); assertThat(result).isEqualTo(departmentDesignation); }
|
### Question:
DepartmentDesignationService { public void create(DepartmentDesignation departmentDesignation) { departmentDesignationRepository.create(departmentDesignation); } DepartmentDesignation getDepartmentDesignation(Long id); DepartmentDesignation getByDepartmentAndDesignation(Long department, Long designation, String tenantId); void create(DepartmentDesignation departmentDesignation); }### Answer:
@Test public void test_create() { DepartmentDesignation departmentDesignation = new DepartmentDesignation().builder().departmentId(10L).id(1L).tenantId("default").build(); doNothing().when(departmentDesignationRepository).create(any(DepartmentDesignation.class)); departmentDesignationService.create(departmentDesignation); verify(departmentDesignationRepository).create(any(DepartmentDesignation.class)); }
|
### Question:
ReceivingModeTypeService { public ReceivingModeTypeReq update(final ReceivingModeTypeReq modeTypeReq) { return receivingModeRepository.persistModifyReceivingModeType(modeTypeReq); } ReceivingModeTypeReq create(final ReceivingModeTypeReq modeTypeReq); ReceivingModeTypeReq update(final ReceivingModeTypeReq modeTypeReq); List<ReceivingModeType> getAllReceivingModeTypes(final ReceivingModeTypeGetReq modeTypeGetRequest); boolean checkReceivingModeTypeByNameAndCode(final String code, final String name, final String tenantId, String mode); boolean checkReceivingModeTypeByName(final String code, final String name, final String tenantId, final String mode); boolean checkReceivingModeTypeByCode(final String code, final String tenantId, final String mode); ReceivingModeType sendMessage(String topic, String key, final ReceivingModeTypeReq modeTypeRequest); static final Logger logger; }### Answer:
@Test public void test_Should_Update_ReceivingModeType() { final ReceivingModeType receivingModeType = getReceivingModeType(); final List<ReceivingModeType> receivingModeTypes = new ArrayList<>(); receivingModeTypes.add(receivingModeType); final ReceivingModeTypeReq receivingModeTypeRequest = new ReceivingModeTypeReq(); receivingModeTypeRequest.setModeType(receivingModeType); final ReceivingModeTypeRes receivingModeTypeResponse = new ReceivingModeTypeRes(); receivingModeTypeResponse.setResponseInfo(null); receivingModeTypeResponse.setModeTypes(receivingModeTypes); when(receivingModeTypeService.update(any(ReceivingModeTypeReq.class))).thenReturn(receivingModeTypeRequest); assertTrue(receivingModeTypeRequest.equals(receivingModeTypeService.update(receivingModeTypeRequest))); }
|
### Question:
ReportService { public ResponseEntity<?> reloadResponse( final RequestInfo requestInfo, Exception e) { final MetadataResponse metadataResponses = new MetadataResponse(); final ResponseInfo responseInfo = responseInfoFactory.createResponseInfoFromRequestInfo(requestInfo, true); if(e != null) { responseInfo.setResMsgId("Report reloaded partially with Errors"); } responseInfo.setResMsgId("Report reloaded successfully"); metadataResponses.setRequestInfo(responseInfo); return new ResponseEntity<>(metadataResponses, HttpStatus.OK); } MetadataResponse getMetaData(MetaDataRequest metaDataRequest, String moduleName); ResponseEntity<?> getSuccessResponse(final MetadataResponse metadataResponse, final RequestInfo requestInfo,
String tenantID); ResponseEntity<?> getReportDataSuccessResponse(final List<ReportResponse> reportResponse, final RequestInfo requestInfo
,String tenantId); ResponseEntity<?> getFailureResponse( final RequestInfo requestInfo,
String tenantID); ResponseEntity<?> getFailureResponse( final RequestInfo requestInfo,
String tenantID, Exception e); ResponseEntity<?> reloadResponse( final RequestInfo requestInfo, Exception e); List<ReportResponse> getAllReportData(ReportRequest reportRequest,String moduleName,String authToken); ReportResponse getReportData(ReportRequest reportRequest,String moduleName,String reportName,String authToken); static final Logger LOGGER; }### Answer:
@Test public void testReloadResponse() { }
|
### Question:
RxPresenter implements Presenter<V> { @Override public void bind(NaviFragment fragment) { Timber.tag(getClass().getSimpleName()); this.naviComponent = fragment; this.initFragment(); } @Override void bind(NaviFragment fragment); @Override void bind(NaviDialogFragment fragment); @Override void bind(NaviAppCompatActivity activity); @Override void bind(NaviActivity activity); @Override void resume(); @Override void pause(); @Override void destroy(); void bindView(@NonNull V mpvView); }### Answer:
@Test public void testBindFragment() throws Exception { NaviFragment fragment = new TestFragment(); startFragment(fragment); this.presenter.bind(fragment); this.testBind(fragment); }
@Test public void testBindDialogFragment() throws Exception { NaviDialogFragment fragment = new TestDialogFragment(); startFragment(fragment); this.presenter.bind(fragment); this.testBind(fragment); }
|
### Question:
MainPresenter extends ComponentPresenter<MainPresenter.View, MainComponent> { @Override public void onBindChange(@Nullable View view) { super.onBindChange(view); onView(v -> v.showBinderCounter(++bindCounter)); onView(v -> { if (doInit) { doInit = false; v.showFragment(startingFragment); } }); } @Inject MainPresenter(Class<? extends Fragment> startingFragment); @Override void onCreate(@Nullable Bundle savedInstanceState); @Override void onSaveInstanceState(@NonNull Bundle outState); @Override void onBindChange(@Nullable View view); }### Answer:
@Test public void testCount() throws Throwable { MainPresenter mainPresenter = new MainPresenter(null); verify(view, never()).showBinderCounter(anyInt()); mainPresenter.onBindChange(view); verify(view).showBinderCounter(1); mainPresenter.onBindChange(null); mainPresenter.onBindChange(view); verify(view).showBinderCounter(2); }
|
### Question:
UserService { public boolean login(String username, String password) { List<String> permissions = apiClient.authenticate(username, password); return permissions.contains("ADMIN"); } @Inject UserService(Application application); boolean login(String username, String password); }### Answer:
@Test public void givenNoPermissions_whenLogin_returnFalse() throws Exception { when(apiClient.authenticate(username, password)).thenReturn(Lists.<String>newArrayList()); assertFalse(userService.login(username, password)); }
@Test public void givenUserPermission_whenLogin_returnFalse() throws Exception { when(apiClient.authenticate(username, password)).thenReturn(Lists.newArrayList("USER")); assertFalse(userService.login(username, password)); }
@Test public void givenAdminPermission_whenLogin_returnTrue() throws Exception { when(apiClient.authenticate(username, password)).thenReturn(Lists.newArrayList("ADMIN")); assertTrue(userService.login(username, password)); }
|
### Question:
AbstractWizard implements Wizard<T> { public void addPage(@Nonnull WizardPage<T> page) { page.setUpdateDelegate(delegate); page.setContext(context); page.init(dataObject); wizardPages.add(page); } @Inject AbstractWizard(T dataObject); Map<String, String> getContext(); T getDataObject(); void addPage(@Nonnull WizardPage<T> page); void addPage(@Nonnull WizardPage<T> page, int index, boolean replace); @Override void setUpdateDelegate(@Nonnull UpdateDelegate delegate); @Nullable @Override WizardPage<T> navigateToFirst(); @Nullable @Override WizardPage<T> navigateToNext(); @Nullable @Override WizardPage<T> navigateToPrevious(); @Override boolean hasNext(); @Override boolean hasPrevious(); @Override boolean canComplete(); }### Answer:
@Test public void testAddPage() throws Exception { wizard.addPage(page1); wizard.addPage(page2); wizard.addPage(page3); verify(page1).setUpdateDelegate(eq(updateDelegate)); verify(page1).setContext(anyMapOf(String.class, String.class)); verify(page1).init(eq(dataObject)); verify(page2).setUpdateDelegate(eq(updateDelegate)); verify(page2).setContext(anyMapOf(String.class, String.class)); verify(page2).init(eq(dataObject)); verify(page3).setUpdateDelegate(eq(updateDelegate)); verify(page3).setContext(anyMapOf(String.class, String.class)); verify(page3).init(eq(dataObject)); assertEquals(page1, wizard.navigateToFirst()); assertEquals(page2, wizard.navigateToNext()); assertEquals(page3, wizard.navigateToNext()); assertNull(wizard.navigateToNext()); }
|
### Question:
MessageDialogPresenter implements MessageDialog, MessageDialogView.ActionDelegate { @Override public void accepted() { this.view.closeDialog(); if (this.confirmCallback != null) { this.confirmCallback.accepted(); } } @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted("title") String title,
@Nonnull @Assisted("message") String message,
@Nullable @Assisted ConfirmCallback confirmCallback); @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted String title,
@Nonnull @Assisted IsWidget content,
@Nullable @Assisted ConfirmCallback confirmCallback); @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted("title") String title,
@Nonnull @Assisted IsWidget content,
@Nullable @Assisted ConfirmCallback confirmCallback,
@Nullable @Assisted("confirmButtonText") String confirmButtonText); @Override void accepted(); @Override void show(); }### Answer:
@Test public void shouldNotCallCallbackOnAccepted() throws Exception { presenter = new MessageDialogPresenter(view, TITLE, MESSAGE, null); presenter.accepted(); verify(view).closeDialog(); verify(confirmCallback, never()).accepted(); }
@Test public void shouldCallCallbackOnAccepted() throws Exception { presenter.accepted(); verify(view).closeDialog(); verify(confirmCallback).accepted(); }
|
### Question:
MessageDialogPresenter implements MessageDialog, MessageDialogView.ActionDelegate { @Override public void show() { this.view.showDialog(); } @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted("title") String title,
@Nonnull @Assisted("message") String message,
@Nullable @Assisted ConfirmCallback confirmCallback); @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted String title,
@Nonnull @Assisted IsWidget content,
@Nullable @Assisted ConfirmCallback confirmCallback); @AssistedInject MessageDialogPresenter(@Nonnull MessageDialogView view,
@Nonnull @Assisted("title") String title,
@Nonnull @Assisted IsWidget content,
@Nullable @Assisted ConfirmCallback confirmCallback,
@Nullable @Assisted("confirmButtonText") String confirmButtonText); @Override void accepted(); @Override void show(); }### Answer:
@Test public void shouldShowView() throws Exception { presenter.show(); verify(view).showDialog(); }
|
### Question:
InputDialogFooter extends Composite { @UiHandler("okButton") public void handleOkClick(final ClickEvent event) { this.actionDelegate.accepted(); } @Inject InputDialogFooter(final @Nonnull UILocalizationConstant messages); void setDelegate(final ActionDelegate delegate); @UiHandler("okButton") void handleOkClick(final ClickEvent event); @UiHandler("cancelButton") void handleCancelClick(final ClickEvent event); }### Answer:
@Test public void shouldCallAcceptedOnOkClicked() throws Exception { footer.handleOkClick(mock(ClickEvent.class)); verify(actionDelegate).accepted(); }
|
### Question:
InputDialogFooter extends Composite { @UiHandler("cancelButton") public void handleCancelClick(final ClickEvent event) { this.actionDelegate.cancelled(); } @Inject InputDialogFooter(final @Nonnull UILocalizationConstant messages); void setDelegate(final ActionDelegate delegate); @UiHandler("okButton") void handleOkClick(final ClickEvent event); @UiHandler("cancelButton") void handleCancelClick(final ClickEvent event); }### Answer:
@Test public void shouldCallCancelledOnCancelClicked() throws Exception { footer.handleCancelClick(mock(ClickEvent.class)); verify(actionDelegate).cancelled(); }
|
### Question:
InputDialogPresenter implements InputDialog, InputDialogView.ActionDelegate { @Override public void cancelled() { this.view.closeDialog(); if (this.cancelCallback != null) { this.cancelCallback.cancelled(); } } @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nonnull @Assisted("initialValue") String initialValue,
final @Nonnull @Assisted("selectionStartIndex") Integer selectionStartIndex,
final @Nonnull @Assisted("selectionLength") Integer selectionLength,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); @Override InputDialog withValidator(InputValidator inputValidator); }### Answer:
@Test public void shouldCallCallbackOnCanceled() throws Exception { presenter.cancelled(); verify(view).closeDialog(); verify(cancelCallback).cancelled(); }
@Test public void shouldNotCallCallbackOnCanceled() throws Exception { presenter = new InputDialogPresenter(view, TITLE, MESSAGE, inputCallback, null); presenter.cancelled(); verify(view).closeDialog(); verify(cancelCallback, never()).cancelled(); }
|
### Question:
InputDialogPresenter implements InputDialog, InputDialogView.ActionDelegate { @Override public void accepted() { this.view.closeDialog(); if (this.inputCallback != null) { this.inputCallback.accepted(view.getValue()); } } @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nonnull @Assisted("initialValue") String initialValue,
final @Nonnull @Assisted("selectionStartIndex") Integer selectionStartIndex,
final @Nonnull @Assisted("selectionLength") Integer selectionLength,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); @Override InputDialog withValidator(InputValidator inputValidator); }### Answer:
@Test public void shouldCallCallbackOnAccepted() throws Exception { presenter.accepted(); verify(view).closeDialog(); verify(view).getValue(); verify(inputCallback).accepted(anyString()); }
@Test public void shouldNotCallCallbackOnAccepted() throws Exception { presenter = new InputDialogPresenter(view, TITLE, MESSAGE, null, cancelCallback); presenter.accepted(); verify(view).closeDialog(); verify(inputCallback, never()).accepted(anyString()); }
|
### Question:
InputDialogPresenter implements InputDialog, InputDialogView.ActionDelegate { @Override public void show() { this.view.showDialog(); } @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nonnull @Assisted("initialValue") String initialValue,
final @Nonnull @Assisted("selectionStartIndex") Integer selectionStartIndex,
final @Nonnull @Assisted("selectionLength") Integer selectionLength,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); @Override InputDialog withValidator(InputValidator inputValidator); }### Answer:
@Test public void shouldShowView() throws Exception { presenter.show(); verify(view).showDialog(); }
|
### Question:
InputDialogPresenter implements InputDialog, InputDialogView.ActionDelegate { @Override public InputDialog withValidator(InputValidator inputValidator) { this.view.setValidator(inputValidator); return this; } @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject InputDialogPresenter(final @Nonnull InputDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("label") String label,
final @Nonnull @Assisted("initialValue") String initialValue,
final @Nonnull @Assisted("selectionStartIndex") Integer selectionStartIndex,
final @Nonnull @Assisted("selectionLength") Integer selectionLength,
final @Nullable @Assisted InputCallback inputCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); @Override InputDialog withValidator(InputValidator inputValidator); }### Answer:
@Test public void shouldSetValidator() throws Exception { final InputValidator validatorMock = mock(InputValidator.class); presenter.withValidator(validatorMock); verify(view).setValidator(validatorMock); }
|
### Question:
FolderNode extends ItemNode { @Nullable protected AbstractTreeNode<?> createChildNode(ItemReference item) { if ("file".equals(item.getType())) { return getTreeStructure().newFileNode(this, item); } else if ("folder".equals(item.getType()) || "project".equals(item.getType())) { return getTreeStructure().newFolderNode(this, item); } return null; } @Inject FolderNode(@Assisted TreeNode<?> parent,
@Assisted ItemReference data,
@Assisted GenericTreeStructure treeStructure,
EventBus eventBus,
ProjectServiceClient projectServiceClient,
DtoUnmarshallerFactory dtoUnmarshallerFactory); @Override boolean isLeaf(); @Override void refreshChildren(final AsyncCallback<TreeNode<?>> callback); @Nonnull @Override GenericTreeStructure getTreeStructure(); @Override boolean canContainsFolder(); }### Answer:
@Test public void shouldCreateChildFolderNodeForProjectItem() { ItemReference folderItem = mock(ItemReference.class); when(folderItem.getType()).thenReturn("project"); folderNode.createChildNode(folderItem); verify(treeStructure).newFolderNode(eq(folderNode), eq(folderItem)); }
@Test public void shouldCreateChildFileNode() throws Exception { ItemReference fileItem = mock(ItemReference.class); when(fileItem.getType()).thenReturn("file"); folderNode.createChildNode(fileItem); verify(treeStructure).newFileNode(eq(folderNode), eq(fileItem)); }
@Test public void shouldCreateChildFolderNodeForFolderItem() { ItemReference folderItem = mock(ItemReference.class); when(folderItem.getType()).thenReturn("folder"); folderNode.createChildNode(folderItem); verify(treeStructure).newFolderNode(eq(folderNode), eq(folderItem)); }
|
### Question:
ConfirmDialogPresenter implements ConfirmDialog, ConfirmDialogView.ActionDelegate { @Override public void cancelled() { this.view.closeDialog(); if (this.cancelCallback != null) { this.cancelCallback.cancelled(); } } @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("message") String message,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted String title,
final @Nonnull @Assisted IsWidget content,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); }### Answer:
@Test public void shouldCallCallbackOnCanceled() throws Exception { presenter.cancelled(); verify(view).closeDialog(); verify(cancelCallback).cancelled(); }
@Test public void shouldNotCallCallbackOnCanceled() throws Exception { presenter = new ConfirmDialogPresenter(view, TITLE, MESSAGE, confirmCallback, null); presenter.cancelled(); verify(view).closeDialog(); verify(cancelCallback, never()).cancelled(); }
|
### Question:
ConfirmDialogPresenter implements ConfirmDialog, ConfirmDialogView.ActionDelegate { @Override public void accepted() { this.view.closeDialog(); if (this.confirmCallback != null) { this.confirmCallback.accepted(); } } @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("message") String message,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted String title,
final @Nonnull @Assisted IsWidget content,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); }### Answer:
@Test public void shouldCallCallbackOnAccepted() throws Exception { presenter.accepted(); verify(view).closeDialog(); verify(confirmCallback).accepted(); }
@Test public void shouldNotCallCallbackOnAccepted() throws Exception { presenter = new ConfirmDialogPresenter(view, TITLE, MESSAGE, null, cancelCallback); presenter.accepted(); verify(view).closeDialog(); verify(confirmCallback, never()).accepted(); }
|
### Question:
ConfirmDialogPresenter implements ConfirmDialog, ConfirmDialogView.ActionDelegate { @Override public void show() { this.view.showDialog(); } @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted("title") String title,
final @Nonnull @Assisted("message") String message,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @AssistedInject ConfirmDialogPresenter(final @Nonnull ConfirmDialogView view,
final @Nonnull @Assisted String title,
final @Nonnull @Assisted IsWidget content,
final @Nullable @Assisted ConfirmCallback confirmCallback,
final @Nullable @Assisted CancelCallback cancelCallback); @Override void cancelled(); @Override void accepted(); @Override void show(); }### Answer:
@Test public void shouldShowView() throws Exception { presenter.show(); verify(view).showDialog(); }
|
### Question:
ConfirmDialogFooter extends Composite { @UiHandler("okButton") public void handleOkClick(final ClickEvent event) { this.actionDelegate.accepted(); } @Inject ConfirmDialogFooter(final @Nonnull UILocalizationConstant messages); void setDelegate(final ConfirmDialogView.ActionDelegate delegate); @UiHandler("okButton") void handleOkClick(final ClickEvent event); @UiHandler("cancelButton") void handleCancelClick(final ClickEvent event); }### Answer:
@Test public void shouldCallAcceptedOnOkClicked() throws Exception { footer.handleOkClick(mock(ClickEvent.class)); verify(actionDelegate).accepted(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.