Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
method2testcases
stringlengths
118
3.08k
### Question: TechnologyDataProviderImpl implements TechnologyDataProvider { public Optional<Entity> tryFind(final Long id) { return Optional.ofNullable(id).map(i -> getDataDefinition().get(i)); } Optional<Entity> tryFind(final Long id); }### Answer: @Test public final void shouldReturnTechnology() { Entity technologyFromDb = mockEntity(); stubDataDefGetResult(technologyFromDb); Optional<Entity> res = technologyDataProvider.tryFind(1L); Assert.assertEquals(Optional.of(technologyFromDb), res); } @Test public final void shouldReturnEmptyIfIdIsMissing() { Optional<Entity> res = technologyDataProvider.tryFind(null); Assert.assertEquals(Optional.<Entity> empty(), res); } @Test public final void shouldReturnEmptyIfEntityCannotBeFound() { stubDataDefGetResult(null); Optional<Entity> res = technologyDataProvider.tryFind(1L); Assert.assertEquals(Optional.<Entity> empty(), res); }
### Question: TechnologyNameAndNumberGenerator { public String generateNumber(final Entity product) { String numberPrefix = product.getField(ProductFields.NUMBER) + "-"; return numberGeneratorService.generateNumberWithPrefix(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_TECHNOLOGY, 3, numberPrefix); } String generateNumber(final Entity product); String generateName(final Entity product); }### Answer: @Test public final void shouldGenerateNumber() { Entity product = mockEntity(); stubStringField(product, ProductFields.NUMBER, "SomeProductNumber"); technologyNameAndNumberGenerator.generateNumber(product); verify(numberGeneratorService).generateNumberWithPrefix(TechnologiesConstants.PLUGIN_IDENTIFIER, TechnologiesConstants.MODEL_TECHNOLOGY, 3, "SomeProductNumber-"); }
### Question: TechnologyNameAndNumberGenerator { public String generateName(final Entity product) { LocalDate date = LocalDate.now(); String currentDateString = String.format("%s.%s", date.getYear(), date.getMonthValue()); String productName = product.getStringField(ProductFields.NAME); String productNumber = product.getStringField(ProductFields.NUMBER); return translationService.translate("technologies.operation.name.default", LocaleContextHolder.getLocale(), productName, productNumber, currentDateString); } String generateNumber(final Entity product); String generateName(final Entity product); }### Answer: @Test public final void shouldGenerateName() { String productNumber = "SomeProductNumber"; String productName = "Some product name"; Entity product = mockEntity(); stubStringField(product, ProductFields.NUMBER, productNumber); stubStringField(product, ProductFields.NAME, productName); technologyNameAndNumberGenerator.generateName(product); LocalDate date = LocalDate.now(); String expectedThirdArgument = String.format("%s.%s", date.getYear(), date.getMonthValue()); verify(translationService).translate("technologies.operation.name.default", LocaleContextHolder.getLocale(), productName, productNumber, expectedThirdArgument); }
### Question: OperationProductComponentImpl implements InternalOperationProductComponent { @Override public void setField(final String name, final Object value) { entity.setField(name, value); } OperationProductComponentImpl(final OperationCompType operationType, final DataDefinition opcDataDef); @Override void setField(final String name, final Object value); @Override Entity getWrappedEntity(); @Override void setProduct(final Entity product); @Override void setQuantity(final BigDecimal quantity); @Override void setPriority(final int priority); }### Answer: @Test public final void shouldThrowExceptionWhenTryToAddProductWithIncorrectTypeToOutputProductComponent() { performWrongTypeProductTest(buildOpoc()); verify(wrappedEntity, Mockito.never()).setField(OperationProductInComponentFields.PRODUCT, product); } @Test public final void shouldThrowExceptionWhenTryToAddProductWithIncorrectTypeToInputProductComponent() { performWrongTypeProductTest(buildOpic()); verify(wrappedEntity, Mockito.never()).setField(OperationProductOutComponentFields.PRODUCT, product); } @Test public final void shouldNotThrowExceptionWhenAddingProductWithCorrectTypeToOutputProductComponent() { performCorrectTypeProductTest(buildOpoc()); verify(wrappedEntity).setField(OperationProductOutComponentFields.PRODUCT, product); } @Test public final void shouldNotThrowExceptionWhenAddingProductWithCorrectTypeToInputProductComponent() { performCorrectTypeProductTest(buildOpic()); verify(wrappedEntity).setField(OperationProductInComponentFields.PRODUCT, product); }
### Question: TechnologyTreeValidationServiceImpl implements TechnologyTreeValidationService { @Override public Map<String, Set<Entity>> checkConsumingTheSameProductFromManySubOperations(final EntityTree technologyTree) { Map<String, Set<Entity>> parentToProductsMap = Maps.newHashMap(); if (technologyTree != null && !technologyTree.isEmpty()) { final EntityTreeNode rootNode = technologyTree.getRoot(); collectChildrenProducingTheSameParentInputs(parentToProductsMap, rootNode); } return parentToProductsMap; } @Override final Map<String, Set<String>> checkConsumingManyProductsFromOneSubOp(final EntityTree technologyTree); @Override Map<String, Set<Entity>> checkConsumingTheSameProductFromManySubOperations(final EntityTree technologyTree); }### Answer: @Test public final void shouldReturnNotEmptyMapIfSubOpsProduceTheSameOutputsWhichAreConsumed() { Entity product1 = mockProductComponent(1L); Entity product2 = mockProductComponent(2L); Entity product3 = mockProductComponent(3L); Entity product4 = mockProductComponent(4L); Entity product5 = mockProductComponent(5L); Entity product6 = mockProductComponent(6L); EntityTreeNode node3 = mockOperationComponent(3L, "3.", newArrayList(product5), newArrayList(product2, product3)); EntityTreeNode node2 = mockOperationComponent(2L, "2.", newArrayList(product6), newArrayList(product2, product4)); EntityTreeNode node1 = mockOperationComponent(1L, "1.", newArrayList(product2), newArrayList(product1), newArrayList(node2, node3)); given(tree.getRoot()).willReturn(node1); Map<String, Set<Entity>> returnedMap = technologyTreeValidationService .checkConsumingTheSameProductFromManySubOperations(tree); assertNotNull(returnedMap); assertFalse(returnedMap.isEmpty()); assertEquals(1, returnedMap.size()); assertTrue(returnedMap.containsKey("1.")); assertTrue(returnedMap.get("1.").contains(product2)); }
### Question: PPSReportHooks { public boolean checkIfIsMoreThatFiveDays(final DataDefinition reportDD, final Entity report) { int days = ppsReportXlsHelper.getNumberOfDaysBetweenGivenDates(report); if (days > 7) { report.addError(reportDD.getField(PPSReportFields.DATE_FROM), "productionPerShift.report.onlyFiveDays"); report.addError(reportDD.getField(PPSReportFields.DATE_TO), "productionPerShift.report.onlyFiveDays"); return false; } return true; } boolean checkIfIsMoreThatFiveDays(final DataDefinition reportDD, final Entity report); final boolean validateDates(final DataDefinition reportDD, final Entity report); void clearGenerated(final DataDefinition reportDD, final Entity report); }### Answer: @Test public void shouldReturnFalseWhenCheckIfIsMoreThatFiveDays() { given(ppsReportXlsHelper.getNumberOfDaysBetweenGivenDates(report)).willReturn(10); boolean result = hooks.checkIfIsMoreThatFiveDays(reportDD, report); Assert.assertFalse(result); verify(report, times(2)).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Test public void shouldReturnTrueWhenCheckIfIsMoreThatFiveDays() { given(ppsReportXlsHelper.getNumberOfDaysBetweenGivenDates(report)).willReturn(3); boolean result = hooks.checkIfIsMoreThatFiveDays(reportDD, report); Assert.assertTrue(result); verify(report, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: PPSReportHooks { public void clearGenerated(final DataDefinition reportDD, final Entity report) { report.setField(PPSReportFields.GENERATED, false); report.setField(PPSReportFields.FILE_NAME, null); } boolean checkIfIsMoreThatFiveDays(final DataDefinition reportDD, final Entity report); final boolean validateDates(final DataDefinition reportDD, final Entity report); void clearGenerated(final DataDefinition reportDD, final Entity report); }### Answer: @Test public void shouldClearGenerated() { hooks.clearGenerated(reportDD, report); verify(report, times(2)).setField(Mockito.anyString(), Mockito.any()); }
### Question: ProductionPerShiftDetailsHooks { void fillTechnologyOperationLookup(final ViewDefinitionState view, final Entity technology) { LookupComponent technologyOperationLookup = (LookupComponent) view.getComponentByReference(OPERATION_LOOKUP_REF); for (Entity rootOperation : technologyOperationDataProvider.findRoot(technology.getId()).asSet()) { technologyOperationLookup.setFieldValue(rootOperation.getId()); technologyOperationLookup.requestComponentUpdateState(); } technologyOperationLookup.setEnabled(true); } void onBeforeRender(final ViewDefinitionState view); ProgressType resolveProgressType(final ViewDefinitionState view); void disableReasonOfCorrection(final ViewDefinitionState view); void setProductAndFillProgressForDays(final ViewDefinitionState view); boolean isCorrectedPlan(final ViewDefinitionState view); void setProductAndFillProgressForDays(final ViewDefinitionState view, final AwesomeDynamicListComponent progressForDaysADL, final OrderState orderState, final ProgressType progressType); }### Answer: @Test public void shouldAddRootForOperation() throws Exception { final Long rootOperationId = 2L; LookupComponent technologyOperationLookup = mockLookup(mockEntity()); stubViewComponent(OPERATION_LOOKUP_REF, technologyOperationLookup); Entity rootOperation = mockEntity(rootOperationId); given(technologyOperationDataProvider.findRoot(anyLong())).willReturn(Optional.of(rootOperation)); productionPerShiftDetailsHooks.fillTechnologyOperationLookup(view, technology); verify(technologyOperationLookup).setFieldValue(rootOperationId); }
### Question: ProductionPerShiftDetailsHooks { void setupProgressTypeComboBox(final ViewDefinitionState view, final OrderState orderState, final ProgressType progressType) { FieldComponent plannedProgressType = (FieldComponent) view.getComponentByReference(PROGRESS_TYPE_COMBO_REF); plannedProgressType.setFieldValue(progressType.getStringValue()); plannedProgressType.requestComponentUpdateState(); plannedProgressType.setEnabled(orderState != OrderState.PENDING); } void onBeforeRender(final ViewDefinitionState view); ProgressType resolveProgressType(final ViewDefinitionState view); void disableReasonOfCorrection(final ViewDefinitionState view); void setProductAndFillProgressForDays(final ViewDefinitionState view); boolean isCorrectedPlan(final ViewDefinitionState view); void setProductAndFillProgressForDays(final ViewDefinitionState view, final AwesomeDynamicListComponent progressForDaysADL, final OrderState orderState, final ProgressType progressType); }### Answer: @Test public void shouldEnabledPlannedProgressTypeForInProgressOrder() throws Exception { ProgressType progressType = ProgressType.PLANNED; productionPerShiftDetailsHooks.setupProgressTypeComboBox(view, OrderState.IN_PROGRESS, progressType); verify(progressTypeComboBox).setFieldValue(progressType.getStringValue()); verify(progressTypeComboBox).setEnabled(true); }
### Question: DeliveriesColumnLoaderTSFD { public void addColumnsForDeliveriesTSFD() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForDeliveries(TechSubcontrForDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesTSFD(); void deleteColumnsForDeliveriesTSFD(); void addColumnsForOrdersTSFD(); void deleteColumnsForOrdersTSFD(); }### Answer: @Test public void shouldAddColumnsForDeliveriesTSFD() { deliveriesColumnLoaderTSFD.addColumnsForDeliveriesTSFD(); verify(deliveriesColumnLoaderService).fillColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderTSFD { public void deleteColumnsForDeliveriesTSFD() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForDeliveries(TechSubcontrForDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesTSFD(); void deleteColumnsForDeliveriesTSFD(); void addColumnsForOrdersTSFD(); void deleteColumnsForOrdersTSFD(); }### Answer: @Test public void shouldDeleteTSFDcolumnsForDeliveries() { deliveriesColumnLoaderTSFD.deleteColumnsForDeliveriesTSFD(); verify(deliveriesColumnLoaderService).clearColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderTSFD { public void addColumnsForOrdersTSFD() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for orders table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForOrders(TechSubcontrForDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesTSFD(); void deleteColumnsForDeliveriesTSFD(); void addColumnsForOrdersTSFD(); void deleteColumnsForOrdersTSFD(); }### Answer: @Test public void shouldAddColumnsForOrdersTSFD() { deliveriesColumnLoaderTSFD.addColumnsForOrdersTSFD(); verify(deliveriesColumnLoaderService).fillColumnsForOrders(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderTSFD { public void deleteColumnsForOrdersTSFD() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for orders table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForOrders(TechSubcontrForDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesTSFD(); void deleteColumnsForDeliveriesTSFD(); void addColumnsForOrdersTSFD(); void deleteColumnsForOrdersTSFD(); }### Answer: @Test public void shouldDeleteColumnsForOrdersTSFD() { deliveriesColumnLoaderTSFD.deleteColumnsForOrdersTSFD(); verify(deliveriesColumnLoaderService).clearColumnsForOrders(Mockito.anyString()); }
### Question: TechSubcontrForDeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantEnable() { deliveriesColumnLoaderTSFD.addColumnsForDeliveriesTSFD(); deliveriesColumnLoaderTSFD.addColumnsForOrdersTSFD(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantEnable() { techSubcontrForDeliveriesOnStartupService.multiTenantEnable(); verify(deliveriesColumnLoaderTSFD).addColumnsForDeliveriesTSFD(); verify(deliveriesColumnLoaderTSFD).addColumnsForOrdersTSFD(); }
### Question: TechSubcontrForDeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantDisable() { deliveriesColumnLoaderTSFD.deleteColumnsForDeliveriesTSFD(); deliveriesColumnLoaderTSFD.deleteColumnsForOrdersTSFD(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantDisable() { techSubcontrForDeliveriesOnStartupService.multiTenantDisable(); verify(deliveriesColumnLoaderTSFD).deleteColumnsForDeliveriesTSFD(); verify(deliveriesColumnLoaderTSFD).deleteColumnsForOrdersTSFD(); }
### Question: CostCalculationValidators { public boolean checkIfTheTechnologyHasCorrectState(final DataDefinition costCalculationDD, final Entity costCalculation) { Entity technology = costCalculation.getBelongsToField(CostCalculationFields.TECHNOLOGY); String state = technology.getStringField(TechnologyFields.STATE); if (TechnologyState.DRAFT.getStringValue().equals(state) || TechnologyState.DECLINED.getStringValue().equals(state)) { costCalculation.addError(costCalculationDD.getField(CostCalculationFields.TECHNOLOGY), "costNormsForOperation.messages.fail.incorrectState"); return false; } return true; } boolean checkIfTheTechnologyHasCorrectState(final DataDefinition costCalculationDD, final Entity costCalculation); boolean checkIfCurrentGlobalIsSelected(final DataDefinition costCalculationDD, final Entity costCalculation); boolean ifSourceOfMaterialIsFromOrderThenOrderIsNeeded(final DataDefinition costCalculationDD, final Entity costCalculation); }### Answer: @Test public void shouldTechnologyHasIncorrectState() { given(costCalculation.getBelongsToField(CostCalculationFields.TECHNOLOGY)).willReturn(technology); given(technology.getStringField(TechnologyFields.STATE)).willReturn(TechnologyStateStringValues.DRAFT); boolean result = costCalculationValidators.checkIfTheTechnologyHasCorrectState(costCalculationDD, costCalculation); assertFalse(result); } @Test public void shouldTechnologyHasCorrectState() { given(costCalculation.getBelongsToField(CostCalculationFields.TECHNOLOGY)).willReturn(technology); given(technology.getStringField(TechnologyFields.STATE)).willReturn(TechnologyStateStringValues.CHECKED); boolean result = costCalculationValidators.checkIfTheTechnologyHasCorrectState(costCalculationDD, costCalculation); assertTrue(result); }
### Question: StaffDetailsHooks { public void enabledIndividualCost(final ViewDefinitionState view) { FieldComponent individual = (FieldComponent) view.getComponentByReference("determinedIndividual"); FieldComponent individualLaborCost = (FieldComponent) view.getComponentByReference("individualLaborCost"); if (individual.getFieldValue() != null && individual.getFieldValue().equals("1")) { individualLaborCost.setEnabled(true); } else { individualLaborCost.setEnabled(false); } individualLaborCost.requestComponentUpdateState(); } void enabledIndividualCost(final ViewDefinitionState view); void setCurrency(final ViewDefinitionState view); void fillFieldAboutWageGroup(final ViewDefinitionState view); }### Answer: @Test public void shouldEnabledFieldWhenCheckBoxIsSelected() throws Exception { String result = "1"; when(view.getComponentByReference("determinedIndividual")).thenReturn(field1); when(view.getComponentByReference("individualLaborCost")).thenReturn(field2); when(field1.getFieldValue()).thenReturn(result); detailsHooks.enabledIndividualCost(view); Mockito.verify(field2).setEnabled(true); } @Test public void shouldDisabledFieldWhenCheckBoxIsSelected() throws Exception { String result = "0"; when(view.getComponentByReference("determinedIndividual")).thenReturn(field1); when(view.getComponentByReference("individualLaborCost")).thenReturn(field2); when(field1.getFieldValue()).thenReturn(result); detailsHooks.enabledIndividualCost(view); Mockito.verify(field2).setEnabled(false); }
### Question: StaffDetailsHooks { public void setCurrency(final ViewDefinitionState view) { FieldComponent laborHourlyCostUNIT = (FieldComponent) view.getComponentByReference("individualLaborCostCURRENCY"); FieldComponent laborCostFromWageGroupsUNIT = (FieldComponent) view .getComponentByReference("laborCostFromWageGroupsCURRENCY"); laborHourlyCostUNIT.setFieldValue(currencyService.getCurrencyAlphabeticCode()); laborCostFromWageGroupsUNIT.setFieldValue(currencyService.getCurrencyAlphabeticCode()); laborHourlyCostUNIT.requestComponentUpdateState(); laborCostFromWageGroupsUNIT.requestComponentUpdateState(); } void enabledIndividualCost(final ViewDefinitionState view); void setCurrency(final ViewDefinitionState view); void fillFieldAboutWageGroup(final ViewDefinitionState view); }### Answer: @Test public void shouldFillFieldCurrency() throws Exception { String currency = "PLN"; when(view.getComponentByReference("individualLaborCostCURRENCY")).thenReturn(field1); when(view.getComponentByReference("laborCostFromWageGroupsCURRENCY")).thenReturn(field2); when(currencyService.getCurrencyAlphabeticCode()).thenReturn(currency); detailsHooks.setCurrency(view); Mockito.verify(field1).setFieldValue(currency); Mockito.verify(field2).setFieldValue(currency); }
### Question: StaffDetailsHooks { public void fillFieldAboutWageGroup(final ViewDefinitionState view) { LookupComponent lookup = (LookupComponent) view.getComponentByReference("wageGroup"); Entity wageGroup = lookup.getEntity(); FieldComponent laborCostFromWageGroups = (FieldComponent) view.getComponentByReference("laborCostFromWageGroups"); FieldComponent superiorWageGroups = (FieldComponent) view.getComponentByReference("superiorWageGroups"); if (wageGroup != null) { laborCostFromWageGroups.setFieldValue(wageGroup.getField(LABOR_HOURLY_COST)); superiorWageGroups.setFieldValue(wageGroup.getStringField(SUPERIOR_WAGE_GROUP)); } else { laborCostFromWageGroups.setFieldValue(null); superiorWageGroups.setFieldValue(null); } } void enabledIndividualCost(final ViewDefinitionState view); void setCurrency(final ViewDefinitionState view); void fillFieldAboutWageGroup(final ViewDefinitionState view); }### Answer: @Test public void shouldFillFieldValuesOfSelectedWageGroup() throws Exception { String superiorWageGroup = "1234"; when(view.getComponentByReference("wageGroup")).thenReturn(lookup); when(lookup.getEntity()).thenReturn(wageGroup); when(view.getComponentByReference("laborCostFromWageGroups")).thenReturn(field1); when(view.getComponentByReference("superiorWageGroups")).thenReturn(field2); when(wageGroup.getField(LABOR_HOURLY_COST)).thenReturn(BigDecimal.ONE); when(wageGroup.getStringField(SUPERIOR_WAGE_GROUP)).thenReturn(superiorWageGroup); detailsHooks.fillFieldAboutWageGroup(view); Mockito.verify(field1).setFieldValue(BigDecimal.ONE); Mockito.verify(field2).setFieldValue(superiorWageGroup); }
### Question: WageGroupsDetailsHooks { public void setCurrency(final ViewDefinitionState view) { FieldComponent individualLaborCostUNIT = (FieldComponent) view .getComponentByReference(WageGroupFields.LABOR_HOURLY_COST_CURRENCY); individualLaborCostUNIT.setFieldValue(currencyService.getCurrencyAlphabeticCode()); individualLaborCostUNIT.requestComponentUpdateState(); } void setCurrency(final ViewDefinitionState view); }### Answer: @Test public void shouldFillFieldWithCurrency() throws Exception { String currency = "pln"; when(view.getComponentByReference("laborHourlyCostCURRENCY")).thenReturn(field); when(currencyService.getCurrencyAlphabeticCode()).thenReturn(currency); hooks.setCurrency(view); Mockito.verify(field).setFieldValue(currency); }
### Question: StaffHooks { public void saveLaborHourlyCost(final DataDefinition dataDefinition, final Entity entity) { boolean individual = entity.getBooleanField(DETERMINED_INDIVIDUAL); if (individual) { entity.setField("laborHourlyCost", entity.getField(INDIVIDUAL_LABOR_COST)); } else { Entity wageGroup = entity.getBelongsToField(WAGE_GROUP); if (wageGroup == null) { entity.setField("laborHourlyCost", null); return; } entity.setField("laborHourlyCost", wageGroup.getField(LABOR_HOURLY_COST)); } } void saveLaborHourlyCost(final DataDefinition dataDefinition, final Entity entity); }### Answer: @Test public void shouldSaveIndividualCost() throws Exception { when(entity.getBooleanField(DETERMINED_INDIVIDUAL)).thenReturn(true); when(entity.getField(INDIVIDUAL_LABOR_COST)).thenReturn(BigDecimal.ONE); hooks.saveLaborHourlyCost(dataDefinition, entity); Mockito.verify(entity).setField("laborHourlyCost", BigDecimal.ONE); } @Test public void shouldReturnWhenWageDoesnotExists() throws Exception { when(entity.getBooleanField(DETERMINED_INDIVIDUAL)).thenReturn(false); when(entity.getBelongsToField(WAGE_GROUP)).thenReturn(null); hooks.saveLaborHourlyCost(dataDefinition, entity); Mockito.verify(entity).setField("laborHourlyCost", null); } @Test public void shouldSaveCostFromWageGroup() throws Exception { when(entity.getBooleanField(DETERMINED_INDIVIDUAL)).thenReturn(false); when(entity.getBelongsToField(WAGE_GROUP)).thenReturn(wageGroup); when(wageGroup.getField(LABOR_HOURLY_COST)).thenReturn(BigDecimal.TEN); hooks.saveLaborHourlyCost(dataDefinition, entity); Mockito.verify(entity).setField("laborHourlyCost", BigDecimal.TEN); }
### Question: DeliveriesColumnLoaderCNID { public void addColumnsForDeliveriesCNID() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForDeliveries(CatNumbersInDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesCNID(); void deleteColumnsForDeliveriesCNID(); void addColumnsForOrdersCNID(); void deleteColumnsForOrdersCNID(); }### Answer: @Test public void shouldAddColumnsForDeliveriesCNID() { deliveriesColumnLoaderCNID.addColumnsForDeliveriesCNID(); verify(deliveriesColumnLoaderService).fillColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderCNID { public void deleteColumnsForDeliveriesCNID() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForDeliveries(CatNumbersInDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesCNID(); void deleteColumnsForDeliveriesCNID(); void addColumnsForOrdersCNID(); void deleteColumnsForOrdersCNID(); }### Answer: @Test public void shouldDeleteColumnsForDeliveriesCNID() { deliveriesColumnLoaderCNID.deleteColumnsForDeliveriesCNID(); verify(deliveriesColumnLoaderService).clearColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderCNID { public void addColumnsForOrdersCNID() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for orders table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForOrders(CatNumbersInDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesCNID(); void deleteColumnsForDeliveriesCNID(); void addColumnsForOrdersCNID(); void deleteColumnsForOrdersCNID(); }### Answer: @Test public void shouldAddColumnsForOrdersCNID() { deliveriesColumnLoaderCNID.addColumnsForOrdersCNID(); verify(deliveriesColumnLoaderService).fillColumnsForOrders(Mockito.anyString()); }
### Question: DeliveriesColumnLoaderCNID { public void deleteColumnsForOrdersCNID() { if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForOrders(CatNumbersInDeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveriesCNID(); void deleteColumnsForDeliveriesCNID(); void addColumnsForOrdersCNID(); void deleteColumnsForOrdersCNID(); }### Answer: @Test public void shouldDeleteColumnsForOrdersCNID() { deliveriesColumnLoaderCNID.deleteColumnsForOrdersCNID(); verify(deliveriesColumnLoaderService).clearColumnsForOrders(Mockito.anyString()); }
### Question: OrderedProductHooksCNID { public void updateOrderedProductCatalogNumber(final DataDefinition orderedProductDD, final Entity orderedProduct) { catNumbersInDeliveriesService.updateProductCatalogNumber(orderedProduct); } void updateOrderedProductCatalogNumber(final DataDefinition orderedProductDD, final Entity orderedProduct); }### Answer: @Test public void shouldUpdateOrderedProductCatalogNumber() { orderedProductHooksCNID.updateOrderedProductCatalogNumber(orderedProductDD, orderedProduct); verify(catNumbersInDeliveriesService).updateProductCatalogNumber(orderedProduct); }
### Question: DeliveredProductHooksCNID { public void updateDeliveredProductCatalogNumber(final DataDefinition deliveredProductDD, final Entity deliveredProduct) { catNumbersInDeliveriesService.updateProductCatalogNumber(deliveredProduct); } void updateDeliveredProductCatalogNumber(final DataDefinition deliveredProductDD, final Entity deliveredProduct); }### Answer: @Test public void shouldUpdateDeliveredProductCatalogNumber() { deliveredProductHooksCNID.updateDeliveredProductCatalogNumber(deliveredProductDD, deliveredProduct); verify(catNumbersInDeliveriesService).updateProductCatalogNumber(deliveredProduct); }
### Question: DeliveryHooksCNID { public void updateOrderedProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery) { catNumbersInDeliveriesService.updateProductsCatalogNumbers(delivery, ORDERED_PRODUCTS); } void updateOrderedProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery); void updateDeliveredProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery); }### Answer: @Test public void shouldUpdateOrderedProductsCatalogNumbers() { deliveryHooksCNID.updateOrderedProductsCatalogNumbers(deliveryDD, delivery); verify(catNumbersInDeliveriesService).updateProductsCatalogNumbers(delivery, ORDERED_PRODUCTS); }
### Question: DeliveryHooksCNID { public void updateDeliveredProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery) { catNumbersInDeliveriesService.updateProductsCatalogNumbers(delivery, DELIVERED_PRODUCTS); } void updateOrderedProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery); void updateDeliveredProductsCatalogNumbers(final DataDefinition deliveryDD, final Entity delivery); }### Answer: @Test public void shouldUpdateDeliveredProductsCatalogNumbers() { deliveryHooksCNID.updateDeliveredProductsCatalogNumbers(deliveryDD, delivery); verify(catNumbersInDeliveriesService).updateProductsCatalogNumbers(delivery, DELIVERED_PRODUCTS); }
### Question: CatNumbersInDeliveriesServiceImpl implements CatNumbersInDeliveriesService { @Override public void updateProductCatalogNumber(final Entity deliveryProduct) { Entity delivery = deliveryProduct.getBelongsToField(DELIVERY); Entity supplier = delivery.getBelongsToField(SUPPLIER); Entity product = deliveryProduct.getBelongsToField(PRODUCT); Entity productCatalogNumber = productCatalogNumbersService.getProductCatalogNumber(product, supplier); if (productCatalogNumber != null) { deliveryProduct.setField(PRODUCT_CATALOG_NUMBER, productCatalogNumber); } } @Override void updateProductCatalogNumber(final Entity deliveryProduct); @Override void updateProductsCatalogNumbers(final Entity delivery, final String productsName); }### Answer: @Test public void shouldntUpdateProductCatalogNumberIfEntityIsntSaved() { given(deliveryProduct.getBelongsToField(DELIVERY)).willReturn(delivery); given(delivery.getBelongsToField(SUPPLIER)).willReturn(supplier); given(deliveryProduct.getBelongsToField(PRODUCT)).willReturn(product); given(productCatalogNumbersService.getProductCatalogNumber(product, supplier)).willReturn(null); catNumbersInDeliveriesService.updateProductCatalogNumber(deliveryProduct); verify(deliveryProduct, never()).setField(Mockito.anyString(), Mockito.any(Entity.class)); } @Test public void shouldUpdateProductCatalogNumberIfEntityIsntSaved() { given(deliveryProduct.getBelongsToField(DELIVERY)).willReturn(delivery); given(delivery.getBelongsToField(SUPPLIER)).willReturn(supplier); given(deliveryProduct.getBelongsToField(PRODUCT)).willReturn(product); given(productCatalogNumbersService.getProductCatalogNumber(product, supplier)).willReturn(productCatalogNumber); catNumbersInDeliveriesService.updateProductCatalogNumber(deliveryProduct); verify(deliveryProduct).setField(Mockito.anyString(), Mockito.any(Entity.class)); }
### Question: CatNumbersInDeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantEnable() { deliveriesColumnLoaderCNID.addColumnsForDeliveriesCNID(); deliveriesColumnLoaderCNID.addColumnsForOrdersCNID(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantEnable() { catNumbersInDeliveriesOnStartupService.multiTenantEnable(); verify(deliveriesColumnLoaderCNID).addColumnsForDeliveriesCNID(); verify(deliveriesColumnLoaderCNID).addColumnsForOrdersCNID(); }
### Question: CatNumbersInDeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantDisable() { deliveriesColumnLoaderCNID.deleteColumnsForDeliveriesCNID(); deliveriesColumnLoaderCNID.deleteColumnsForOrdersCNID(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantDisable() { catNumbersInDeliveriesOnStartupService.multiTenantDisable(); verify(deliveriesColumnLoaderCNID).deleteColumnsForDeliveriesCNID(); verify(deliveriesColumnLoaderCNID).deleteColumnsForOrdersCNID(); }
### Question: ParametersListenersO { public void redirectToOrdersParameters(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { Long parameterId = (Long) componentState.getFieldValue(); if (parameterId != null) { String url = "../page/orders/ordersParameters.html?context={\"form.id\":\"" + parameterId + "\"}"; view.redirectTo(url, false, true); } } void redirectToOrdersParameters(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void redirectToDeviationsDictionary(final ViewDefinitionState viewDefinitionState, final ComponentState componentState, final String[] args); void showTimeField(final ViewDefinitionState view, final ComponentState componentState, final String[] args); }### Answer: @Test public void shouldRedirectToOrdersParametersIfParameterIdIsntNull() { Long parameterId = 1L; given(componentState.getFieldValue()).willReturn(parameterId); String url = "../page/orders/ordersParameters.html?context={\"form.id\":\"" + parameterId + "\"}"; parametersListenersO.redirectToOrdersParameters(view, componentState, null); verify(view).redirectTo(url, false, true); } @Test public void shouldntRedirectToOrdersParametersIfParameterIdIsNull() { Long parameterId = null; given(componentState.getFieldValue()).willReturn(parameterId); String url = "../page/orders/ordersParameters.html?context={\"form.id\":\"" + parameterId + "\"}"; parametersListenersO.redirectToOrdersParameters(view, componentState, null); verify(view, never()).redirectTo(url, false, true); }
### Question: ParametersHooksO { public void showTimeFields(final ViewDefinitionState view) { orderService.changeFieldState(view, REASON_NEEDED_WHEN_DELAYED_EFFECTIVE_DATE_FROM, DELAYED_EFFECTIVE_DATE_FROM_TIME); orderService.changeFieldState(view, REASON_NEEDED_WHEN_EARLIER_EFFECTIVE_DATE_FROM, EARLIER_EFFECTIVE_DATE_FROM_TIME); orderService.changeFieldState(view, REASON_NEEDED_WHEN_DELAYED_EFFECTIVE_DATE_TO, DELAYED_EFFECTIVE_DATE_TO_TIME); orderService.changeFieldState(view, REASON_NEEDED_WHEN_EARLIER_EFFECTIVE_DATE_TO, EARLIER_EFFECTIVE_DATE_TO_TIME); } void showTimeFields(final ViewDefinitionState view); void hideTabs(final ViewDefinitionState view); }### Answer: @Test public void shouldShowTimeFields() { parametersHooksO.showTimeFields(view); verify(orderService).changeFieldState(view, REASON_NEEDED_WHEN_DELAYED_EFFECTIVE_DATE_FROM, DELAYED_EFFECTIVE_DATE_FROM_TIME); verify(orderService).changeFieldState(view, REASON_NEEDED_WHEN_EARLIER_EFFECTIVE_DATE_FROM, EARLIER_EFFECTIVE_DATE_FROM_TIME); verify(orderService).changeFieldState(view, REASON_NEEDED_WHEN_DELAYED_EFFECTIVE_DATE_TO, DELAYED_EFFECTIVE_DATE_TO_TIME); verify(orderService).changeFieldState(view, REASON_NEEDED_WHEN_EARLIER_EFFECTIVE_DATE_TO, EARLIER_EFFECTIVE_DATE_TO_TIME); }
### Question: CommonReasonTypeModelHooks { public void updateDate(final Entity reasonTypeEntity, final DeviationModelDescriber deviationModelDescriber) { if (reasonHasNotBeenSavedYet(reasonTypeEntity) || reasonHasChanged(reasonTypeEntity, deviationModelDescriber)) { reasonTypeEntity.setField(CommonReasonTypeFields.DATE, new Date()); } } void updateDate(final Entity reasonTypeEntity, final DeviationModelDescriber deviationModelDescriber); }### Answer: @Test public final void shouldSetCurrentDateOnUpdate() { Date dateBefore = new Date(); stubReasonEntityId(1L); stubFindResults(false); commonReasonTypeModelHooks.updateDate(reasonTypeEntity, deviationModelDescriber); verify(reasonTypeEntity).setField(eq(CommonReasonTypeFields.DATE), dateCaptor.capture()); Date capturedDate = dateCaptor.getValue(); Date dateAfter = new Date(); Assert.assertTrue(capturedDate.compareTo(dateBefore) >= 0 && capturedDate.compareTo(dateAfter) <= 0); } @Test public final void shouldSetCurrentDateOnCreate() { Date dateBefore = new Date(); stubReasonEntityId(null); stubFindResults(false); commonReasonTypeModelHooks.updateDate(reasonTypeEntity, deviationModelDescriber); verify(reasonTypeEntity).setField(eq(CommonReasonTypeFields.DATE), dateCaptor.capture()); Date capturedDate = dateCaptor.getValue(); Date dateAfter = new Date(); Assert.assertTrue(capturedDate.compareTo(dateBefore) >= 0 && capturedDate.compareTo(dateAfter) <= 0); } @Test public final void shouldNotSetCurrentDateIfTypeFieldValueDidNotChange() { stubReasonEntityId(1L); stubFindResults(true); commonReasonTypeModelHooks.updateDate(reasonTypeEntity, deviationModelDescriber); verify(reasonTypeEntity, never()).setField(eq(CommonReasonTypeFields.DATE), any()); }
### Question: OrderDetailsHooks { public void generateOrderNumber(final ViewDefinitionState view) { numberGeneratorService.generateAndInsertNumber(view, OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER, L_FORM, OrderFields.NUMBER); } final void onBeforeRender(final ViewDefinitionState view); void fillRecipeFilterValue(final ViewDefinitionState view); final void fillProductionLine(final ViewDefinitionState view); void fillProductionLine(final LookupComponent productionLineLookup, final Entity technology, final Entity defaultProductionLine); void generateOrderNumber(final ViewDefinitionState view); void fillDefaultTechnology(final ViewDefinitionState view); void disableFieldOrderForm(final ViewDefinitionState view); void disableTechnologiesIfProductDoesNotAny(final ViewDefinitionState view); void setAndDisableState(final ViewDefinitionState view); void changedEnabledFieldForSpecificOrderState(final ViewDefinitionState view); void disableOrderFormForExternalItems(final ViewDefinitionState state); void filterStateChangeHistory(final ViewDefinitionState view); void disabledRibbonWhenOrderIsSynchronized(final ViewDefinitionState view); void compareDeadlineAndEndDate(final ViewDefinitionState view); void compareDeadlineAndStartDate(final ViewDefinitionState view); void setFieldsVisibility(final ViewDefinitionState view); void setFieldsVisibilityAndFill(final ViewDefinitionState view); void fillOrderDescriptionIfTechnologyHasDescription(ViewDefinitionState view); }### Answer: @Test public void shouldGenerateOrderNumber() throws Exception { orderDetailsHooks.generateOrderNumber(view); verify(numberGeneratorService).generateAndInsertNumber(view, OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER, L_FORM, OrderFields.NUMBER); }
### Question: OrderStateValidationService { public void validationOnAccepted(final StateChangeContext stateChangeContext) { final List<String> references = Arrays.asList(DATE_TO, DATE_FROM, PRODUCTION_LINE); checkRequired(references, stateChangeContext); } void validationOnAccepted(final StateChangeContext stateChangeContext); void validationOnInProgress(final StateChangeContext stateChangeContext); void validationOnCompleted(final StateChangeContext stateChangeContext); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenEntityIsNullValidationAccepted() throws Exception { orderStateValidationService.validationOnAccepted(null); }
### Question: OrderStateValidationService { public void validationOnInProgress(final StateChangeContext stateChangeContext) { final List<String> references = Arrays.asList(DATE_TO, DATE_FROM); checkRequired(references, stateChangeContext); } void validationOnAccepted(final StateChangeContext stateChangeContext); void validationOnInProgress(final StateChangeContext stateChangeContext); void validationOnCompleted(final StateChangeContext stateChangeContext); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenEntityIsNullValidationInProgress() throws Exception { orderStateValidationService.validationOnInProgress(null); }
### Question: OrderStateValidationService { public void validationOnCompleted(final StateChangeContext stateChangeContext) { final List<String> fieldNames = Arrays.asList(DATE_TO, DATE_FROM, DONE_QUANTITY); checkRequired(fieldNames, stateChangeContext); } void validationOnAccepted(final StateChangeContext stateChangeContext); void validationOnInProgress(final StateChangeContext stateChangeContext); void validationOnCompleted(final StateChangeContext stateChangeContext); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenEntityIsNullValidationCompleted() throws Exception { orderStateValidationService.validationOnCompleted(null); } @Test public void shouldPerformValidationCompleted() throws Exception { given(order.getField(Mockito.anyString())).willReturn("fieldValue"); given(order.getField(EFFECTIVE_DATE_FROM)).willReturn(new Date(System.currentTimeMillis() - 10000)); orderStateValidationService.validationOnCompleted(stateChangeContext); verify(stateChangeContext, never()).addFieldValidationError(Mockito.anyString(), Mockito.eq(L_MISSING_MESSAGE)); verify(stateChangeContext, never()).addFieldValidationError(Mockito.anyString(), Mockito.eq(L_WRONG_EFFECTIVE_DATE_TO)); }
### Question: OrderStateChangeReasonService { public boolean neededWhenCorrectingDateFrom() { return parameterService.getParameter().getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_FROM); } boolean neededWhenCorrectingDateFrom(); boolean neededWhenCorrectingDateTo(); boolean neededForDecline(); boolean neededForInterrupt(); boolean neededForAbandon(); boolean neededWhenChangingEffectiveDateFrom(); long getEffectiveDateFromDifference(final Entity parameter, final Entity order); long getEffectiveDateToDifference(final Entity parameter, final Entity order); void showReasonForm(final StateChangeContext stateChangeContext, final ViewContextHolder viewContext); }### Answer: @Test public void shouldReturnTrueIfIsReasonNeededWhenCorrectingDateFrom() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_FROM)).willReturn(true); boolean result = orderStateChangeReasonService.neededWhenCorrectingDateFrom(); assertTrue(result); } @Test public void shouldReturnFalseIfIsReasonNeededWhenCorrectingDateFrom() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_FROM)).willReturn(false); boolean result = orderStateChangeReasonService.neededWhenCorrectingDateFrom(); assertFalse(result); }
### Question: OrderStateChangeReasonService { public boolean neededWhenCorrectingDateTo() { return parameterService.getParameter().getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_TO); } boolean neededWhenCorrectingDateFrom(); boolean neededWhenCorrectingDateTo(); boolean neededForDecline(); boolean neededForInterrupt(); boolean neededForAbandon(); boolean neededWhenChangingEffectiveDateFrom(); long getEffectiveDateFromDifference(final Entity parameter, final Entity order); long getEffectiveDateToDifference(final Entity parameter, final Entity order); void showReasonForm(final StateChangeContext stateChangeContext, final ViewContextHolder viewContext); }### Answer: @Test public void shouldReturnTrueIfIsReasonNeededWhenCorrectingDateTo() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_TO)).willReturn(true); boolean result = orderStateChangeReasonService.neededWhenCorrectingDateTo(); assertTrue(result); } @Test public void shouldReturnFalseIfIsReasonNeededWhenCorrectingDateTo() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CORRECTING_DATE_TO)).willReturn(false); boolean result = orderStateChangeReasonService.neededWhenCorrectingDateTo(); assertFalse(result); }
### Question: OrderStateChangeReasonService { public boolean neededForDecline() { return parameterService.getParameter().getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_DECLINED); } boolean neededWhenCorrectingDateFrom(); boolean neededWhenCorrectingDateTo(); boolean neededForDecline(); boolean neededForInterrupt(); boolean neededForAbandon(); boolean neededWhenChangingEffectiveDateFrom(); long getEffectiveDateFromDifference(final Entity parameter, final Entity order); long getEffectiveDateToDifference(final Entity parameter, final Entity order); void showReasonForm(final StateChangeContext stateChangeContext, final ViewContextHolder viewContext); }### Answer: @Test public void shouldReturnTrueIfIsReasonNeededWhenChangingStateToDeclined() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_DECLINED)).willReturn(true); boolean result = orderStateChangeReasonService.neededForDecline(); assertTrue(result); } @Test public void shouldReturnFalseIfIsReasonNeededWhenChangingStateToDeclined() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_DECLINED)).willReturn(false); boolean result = orderStateChangeReasonService.neededForDecline(); assertFalse(result); }
### Question: OrderStateChangeReasonService { public boolean neededForInterrupt() { return parameterService.getParameter().getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_INTERRUPTED); } boolean neededWhenCorrectingDateFrom(); boolean neededWhenCorrectingDateTo(); boolean neededForDecline(); boolean neededForInterrupt(); boolean neededForAbandon(); boolean neededWhenChangingEffectiveDateFrom(); long getEffectiveDateFromDifference(final Entity parameter, final Entity order); long getEffectiveDateToDifference(final Entity parameter, final Entity order); void showReasonForm(final StateChangeContext stateChangeContext, final ViewContextHolder viewContext); }### Answer: @Test public void shouldReturnTrueIfIsReasonNeededWhenChangingStateToInterrupted() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_INTERRUPTED)).willReturn(true); boolean result = orderStateChangeReasonService.neededForInterrupt(); assertTrue(result); } @Test public void shouldReturnFalseIfIsReasonNeededWhenChangingStateToInterrupted() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_INTERRUPTED)).willReturn(false); boolean result = orderStateChangeReasonService.neededForInterrupt(); assertFalse(result); }
### Question: OrderStateChangeReasonService { public boolean neededForAbandon() { return parameterService.getParameter().getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_ABANDONED); } boolean neededWhenCorrectingDateFrom(); boolean neededWhenCorrectingDateTo(); boolean neededForDecline(); boolean neededForInterrupt(); boolean neededForAbandon(); boolean neededWhenChangingEffectiveDateFrom(); long getEffectiveDateFromDifference(final Entity parameter, final Entity order); long getEffectiveDateToDifference(final Entity parameter, final Entity order); void showReasonForm(final StateChangeContext stateChangeContext, final ViewContextHolder viewContext); }### Answer: @Test public void shouldReturnTrueIfIsReasonNeededWhenChangingStateToAbandoned() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_ABANDONED)).willReturn(true); boolean result = orderStateChangeReasonService.neededForAbandon(); assertTrue(result); } @Test public void shouldReturnFalseIfIsReasonNeededWhenChangingStateToAbandoned() { Entity parameter = mock(Entity.class); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBooleanField(REASON_NEEDED_WHEN_CHANGING_STATE_TO_ABANDONED)).willReturn(false); boolean result = orderStateChangeReasonService.neededForAbandon(); assertFalse(result); }
### Question: AssignmentToShiftReportDetailsHooks { public void generateAssignmentToShiftReportNumber(final ViewDefinitionState view) { numberGeneratorService.generateAndInsertNumber(view, AssignmentToShiftConstants.PLUGIN_IDENTIFIER, AssignmentToShiftConstants.MODEL_ASSIGNMENT_TO_SHIFT_REPORT, L_FORM, AssignmentToShiftReportFields.NUMBER); } void generateAssignmentToShiftReportNumber(final ViewDefinitionState view); void disableFields(final ViewDefinitionState view); }### Answer: @Test public void shouldGenerateAssignmentToShiftReportNumber() { hooks.generateAssignmentToShiftReportNumber(view); verify(numberGeneratorService).generateAndInsertNumber(view, AssignmentToShiftConstants.PLUGIN_IDENTIFIER, AssignmentToShiftConstants.MODEL_ASSIGNMENT_TO_SHIFT_REPORT, L_FORM, AssignmentToShiftReportFields.NUMBER); }
### Question: AssignmentToShiftReportHooks { public boolean checkIfIsMoreThatFiveDays(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport) { int days = assignmentToShiftXlsHelper.getNumberOfDaysBetweenGivenDates(assignmentToShiftReport); if (days > 5) { assignmentToShiftReport.addError(assignmentToShiftReportDD.getField(DATE_FROM), "assignmentToShift.assignmentToShift.report.onlyFiveDays"); assignmentToShiftReport.addError(assignmentToShiftReportDD.getField(DATE_TO), "assignmentToShift.assignmentToShift.report.onlyFiveDays"); return false; } return true; } boolean checkIfIsMoreThatFiveDays(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport); void clearGenerated(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport); final boolean validateDates(final DataDefinition dataDefinition, final Entity assignmentToShiftReport); }### Answer: @Test public void shouldReturnFalseWhenCheckIfIsMoreThatFiveDays() { given(assignmentToShiftXlsHelper.getNumberOfDaysBetweenGivenDates(assignmentToShiftReport)).willReturn(10); boolean result = hooks.checkIfIsMoreThatFiveDays(assignmentToShiftReportDD, assignmentToShiftReport); Assert.assertFalse(result); verify(assignmentToShiftReport, times(2)).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Test public void shouldReturnTrueWhenCheckIfIsMoreThatFiveDays() { given(assignmentToShiftXlsHelper.getNumberOfDaysBetweenGivenDates(assignmentToShiftReport)).willReturn(3); boolean result = hooks.checkIfIsMoreThatFiveDays(assignmentToShiftReportDD, assignmentToShiftReport); Assert.assertTrue(result); verify(assignmentToShiftReport, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: AssignmentToShiftReportHooks { public void clearGenerated(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport) { assignmentToShiftReport.setField(GENERATED, false); assignmentToShiftReport.setField(FILE_NAME, null); } boolean checkIfIsMoreThatFiveDays(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport); void clearGenerated(final DataDefinition assignmentToShiftReportDD, final Entity assignmentToShiftReport); final boolean validateDates(final DataDefinition dataDefinition, final Entity assignmentToShiftReport); }### Answer: @Test public void shouldClearGenerated() { hooks.clearGenerated(assignmentToShiftReportDD, assignmentToShiftReport); verify(assignmentToShiftReport, times(2)).setField(Mockito.anyString(), Mockito.any()); }
### Question: AssignmentToShiftHooks { void setInitialState(final Entity assignmentToShift) { stateChangeEntityBuilder.buildInitial(describer, assignmentToShift, AssignmentToShiftState.DRAFT); } void onCreate(final DataDefinition assignmentToShiftDD, final Entity assignmentToShift); void onCopy(final DataDefinition assignmentToShiftDD, final Entity assignmentToShift); boolean onValidate(final DataDefinition assignmentToShiftDD, final Entity assignmentToShift); }### Answer: @Test public void shouldSetInitialState() { assignmentToShiftHooks.setInitialState(assignmentToShift); verify(stateChangeEntityBuilder).buildInitial(describer, assignmentToShift, AssignmentToShiftState.DRAFT); }
### Question: TechnologyStateChangeListenerServiceTNFO { public boolean checkOperationOutputQuantities(final StateChangeContext stateChangeContext) { Entity techology = stateChangeContext.getOwner(); Entity technology = techology.getDataDefinition().get(techology.getId()); List<String> messages = normService.checkOperationOutputQuantities(technology); if (!messages.isEmpty()) { stateChangeContext.addValidationError("technologies.technology.validate.global.error.treeIsNotValid"); StringBuilder builder = new StringBuilder(); for (String message : messages) { builder.append(message); builder.append(", "); } stateChangeContext.addMessage("technologies.technology.validate.error.invalidQuantity", StateMessageType.FAILURE, false, builder.toString()); } return messages.isEmpty(); } boolean checkOperationOutputQuantities(final StateChangeContext stateChangeContext); boolean checkIfAllOperationComponenthHaveTJSet(final StateChangeContext stateChangeContext); }### Answer: @Test public void shouldAlwaysPassIfTheTechnologyIsInDraftState() { given(stateChangeContext.getOwner()).willReturn(technology); given(technology.getDataDefinition()).willReturn(dataDefinition); given(technology.getStringField("state")).willReturn("01draft"); boolean isValid = technologyStateChangeListenerServiceTNFO.checkOperationOutputQuantities(stateChangeContext); assertTrue(isValid); }
### Question: OrderDetailsHooksMR { public void setInputProductsRequiredForTypeFromParameters(final ViewDefinitionState view) { FormComponent orderForm = (FormComponent) view.getComponentByReference(L_FORM); if (orderForm.getEntityId() != null) { return; } FieldComponent inputProductsRequiredForTypeField = (FieldComponent) view .getComponentByReference(OrderFieldsMR.INPUT_PRODUCTS_REQUIRED_FOR_TYPE); String inputProductsRequiredForType = (String) inputProductsRequiredForTypeField.getFieldValue(); if (StringUtils.isEmpty(inputProductsRequiredForType)) { inputProductsRequiredForTypeField.setFieldValue(getInputProductsRequiredForType()); } inputProductsRequiredForTypeField.requestComponentUpdateState(); } void setInputProductsRequiredForTypeFromParameters(final ViewDefinitionState view); }### Answer: @Test public final void shouldSetInputProductsRequiredForTypeFromParameters() { given(inputProductsRequiredForTypeField.getFieldValue()).willReturn(null); orderDetailsHooksMR.setInputProductsRequiredForTypeFromParameters(view); verify(inputProductsRequiredForTypeField).setFieldValue(InputProductsRequiredForType.START_ORDER.getStringValue()); } @Test public final void shouldntSetInputProductsRequiredForTypeFromParameters() { given(inputProductsRequiredForTypeField.getFieldValue()).willReturn( InputProductsRequiredForType.START_ORDER.getStringValue()); orderDetailsHooksMR.setInputProductsRequiredForTypeFromParameters(view); verify(inputProductsRequiredForTypeField, never()).setFieldValue( InputProductsRequiredForType.START_ORDER.getStringValue()); }
### Question: SamplesLoaderResolver { public SamplesLoader resolve() { final SamplesDataset samplesDataset = multiTenantService.getTenantSamplesDataset(); switch (samplesDataset) { case MINIMAL: return minimalSamplesLoader; case TEST: return testSamplesLoader; case GENERATED: return generatedSamplesLoader; case NONE: return dummySamplesLoader; default: throw new IllegalArgumentException("Unsupported dataset: " + samplesDataset); } } SamplesLoader resolve(); }### Answer: @Test public final void shouldReturnMinimalSamplesLoader() throws Exception { given(multiTenantService.getTenantSamplesDataset()).willReturn(SamplesDataset.MINIMAL); SamplesLoader samplesLoader = samplesLoaderResolver.resolve(); assertEquals(minimalSamplesLoader, samplesLoader); } @Test public final void shouldReturnTestSamplesLoader() throws Exception { given(multiTenantService.getTenantSamplesDataset()).willReturn(SamplesDataset.TEST); SamplesLoader samplesLoader = samplesLoaderResolver.resolve(); assertEquals(testSamplesLoader, samplesLoader); } @Test public final void shouldReturnGeneratedSamplesLoader() throws Exception { given(multiTenantService.getTenantSamplesDataset()).willReturn(SamplesDataset.GENERATED); SamplesLoader samplesLoader = samplesLoaderResolver.resolve(); assertEquals(generatedSamplesLoader, samplesLoader); } @Test public final void shouldReturnDummySamplesLoader() throws Exception { given(multiTenantService.getTenantSamplesDataset()).willReturn(SamplesDataset.NONE); SamplesLoader samplesLoader = samplesLoaderResolver.resolve(); assertEquals(dummySamplesLoader, samplesLoader); }
### Question: DeliveriesColumnLoader { public void addColumnsForDeliveries() { if (!deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()) { return; } if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForDeliveries(DeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveries(); void deleteColumnsForDeliveries(); void addColumnsForOrders(); void deleteColumnsForOrders(); }### Answer: @Test public void shouldAddColumnsForDeliveries() { given(deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()).willReturn(true); deliveriesColumnLoader.addColumnsForDeliveries(); verify(deliveriesColumnLoaderService).fillColumnsForDeliveries(Mockito.anyString()); } @Test public void shouldntAddColumnsForDeliveries() { given(deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()).willReturn(false); deliveriesColumnLoader.addColumnsForDeliveries(); verify(deliveriesColumnLoaderService, never()).fillColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoader { public void deleteColumnsForDeliveries() { if (deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()) { return; } if (LOG.isDebugEnabled()) { LOG.debug("Columns for deliveries table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForDeliveries(DeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveries(); void deleteColumnsForDeliveries(); void addColumnsForOrders(); void deleteColumnsForOrders(); }### Answer: @Test public void shouldDeleteColumnsForDeliveries() { given(deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()).willReturn(false); deliveriesColumnLoader.deleteColumnsForDeliveries(); verify(deliveriesColumnLoaderService).clearColumnsForDeliveries(Mockito.anyString()); } @Test public void shouldntDeleteColumnsForDeliveries() { given(deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty()).willReturn(true); deliveriesColumnLoader.deleteColumnsForDeliveries(); verify(deliveriesColumnLoaderService, never()).clearColumnsForDeliveries(Mockito.anyString()); }
### Question: DeliveriesColumnLoader { public void addColumnsForOrders() { if (!deliveriesColumnLoaderService.isColumnsForOrdersEmpty()) { return; } if (LOG.isDebugEnabled()) { LOG.debug("Columns for orders table will be populated ..."); } deliveriesColumnLoaderService.fillColumnsForOrders(DeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveries(); void deleteColumnsForDeliveries(); void addColumnsForOrders(); void deleteColumnsForOrders(); }### Answer: @Test public void shouldAddColumnsForOrders() { given(deliveriesColumnLoaderService.isColumnsForOrdersEmpty()).willReturn(true); deliveriesColumnLoader.addColumnsForOrders(); verify(deliveriesColumnLoaderService).fillColumnsForOrders(Mockito.anyString()); } @Test public void shouldntAddColumnsForOrders() { given(deliveriesColumnLoaderService.isColumnsForOrdersEmpty()).willReturn(false); deliveriesColumnLoader.addColumnsForOrders(); verify(deliveriesColumnLoaderService, never()).fillColumnsForOrders(Mockito.anyString()); }
### Question: DeliveriesColumnLoader { public void deleteColumnsForOrders() { if (deliveriesColumnLoaderService.isColumnsForOrdersEmpty()) { return; } if (LOG.isDebugEnabled()) { LOG.debug("Columns for orders table will be unpopulated ..."); } deliveriesColumnLoaderService.clearColumnsForOrders(DeliveriesConstants.PLUGIN_IDENTIFIER); } void addColumnsForDeliveries(); void deleteColumnsForDeliveries(); void addColumnsForOrders(); void deleteColumnsForOrders(); }### Answer: @Test public void shouldDeleteColumnsForOrders() { given(deliveriesColumnLoaderService.isColumnsForOrdersEmpty()).willReturn(false); deliveriesColumnLoader.deleteColumnsForOrders(); verify(deliveriesColumnLoaderService).clearColumnsForOrders(Mockito.anyString()); } @Test public void shoulntdDeleteColumnsForOrders() { given(deliveriesColumnLoaderService.isColumnsForOrdersEmpty()).willReturn(true); deliveriesColumnLoader.deleteColumnsForOrders(); verify(deliveriesColumnLoaderService, never()).clearColumnsForOrders(Mockito.anyString()); }
### Question: OrderedProductDetailsHooks { public void fillUnitFields(final ViewDefinitionState view) { List<String> referenceNames = Lists.newArrayList("orderedQuantityUnit"); List<String> additionalUnitNames = Lists.newArrayList("additionalQuantityUnit"); deliveriesService.fillUnitFields(view, OrderedProductFields.PRODUCT, referenceNames, additionalUnitNames); fillConversion(view); fillAdditionalCodesLookup(view); } void fillUnitFields(final ViewDefinitionState view); void fillCurrencyFields(final ViewDefinitionState view); }### Answer: @Test public void shouldSetProductUnitWhenProductIsSelected() throws Exception { String unit = "szt"; when(productLookup.getEntity()).thenReturn(product); when(product.getStringField("unit")).thenReturn(unit); orderedProductDetailsHooks.fillUnitFields(view); Mockito.verify(unitField).setFieldValue("szt"); } @Test public void shouldReturnWhenProductIsNull() throws Exception { when(productLookup.getEntity()).thenReturn(null); orderedProductDetailsHooks.fillUnitFields(view); Mockito.verify(unitField).setFieldValue(""); }
### Question: CompanyProductHooks { public boolean checkIfProductIsParticularProduct(final DataDefinition companyProductDD, final Entity companyProduct) { if (!productService.checkIfProductEntityTypeIsCorrect(companyProduct.getBelongsToField(PRODUCT), PARTICULAR_PRODUCT)) { companyProduct.addError(companyProductDD.getField(PRODUCT), "basic.company.message.productIsNotParticularProduct"); return false; } return true; } boolean checkIfProductIsParticularProduct(final DataDefinition companyProductDD, final Entity companyProduct); boolean checkIfProductIsNotAlreadyUsed(final DataDefinition companyProductDD, final Entity companyProduct); boolean checkIfProductHasDefaultSupplier(final DataDefinition companyProductDD, final Entity companyProduct); }### Answer: @Ignore @Test public void shouldReturnTrueWhenCheckIfProductIsParticularProduct() { given(companyProduct.getBelongsToField(PRODUCT)).willReturn(product); given(productService.checkIfProductEntityTypeIsCorrect(product, PARTICULAR_PRODUCT)).willReturn(true); boolean result = companyProductHooks.checkIfProductIsParticularProduct(companyProductDD, companyProduct); assertTrue(result); verify(companyProduct, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Ignore @Test public void shouldReturnFalseWhenCheckIfProductIsParticularProduct() { given(companyProduct.getBelongsToField(PRODUCT)).willReturn(product); given(productService.checkIfProductEntityTypeIsCorrect(product, PARTICULAR_PRODUCT)).willReturn(false); boolean result = companyProductHooks.checkIfProductIsParticularProduct(companyProductDD, companyProduct); assertFalse(result); verify(companyProduct).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: DeviationsReportCriteria { public static DeviationsReportCriteria forDates(final LocalDate fromDate, final Optional<LocalDate> maybeToDate) { checkArguments(fromDate, maybeToDate); return fromLocalDates(fromDate, maybeToDate); } private DeviationsReportCriteria(final Interval searchInterval); static DateTime getDefaultDateTo(); static DeviationsReportCriteria forDates(final LocalDate fromDate, final Optional<LocalDate> maybeToDate); static DeviationsReportCriteria forDates(final DateTime fromDate, final Optional<DateTime> maybeToDate); Interval getSearchInterval(); ImmutableSet<String> getExcludedOrderStates(); @Override boolean equals(final Object obj); @Override int hashCode(); }### Answer: @Test public final void shouldThrowExceptionIfArgumentsAreIncorrect() { try { DeviationsReportCriteria.forDates(null, Optional.of(DateTime.now())); Assert.fail(); } catch (IllegalArgumentException iae) { } try { DeviationsReportCriteria.forDates(DateTime.now(), null); Assert.fail(); } catch (IllegalArgumentException iae) { } try { DeviationsReportCriteria.forDates(DateTime.now().plusDays(1), Optional.of(DateTime.now())); Assert.fail(); } catch (IllegalArgumentException iae) { } }
### Question: CompanyProductHooks { public boolean checkIfProductIsNotAlreadyUsed(final DataDefinition companyProductDD, final Entity companyProduct) { if (!companyProductService.checkIfProductIsNotUsed(companyProduct, PRODUCT, COMPANY, PRODUCTS)) { companyProduct.addError(companyProductDD.getField(PRODUCT), "basic.company.message.productIsAlreadyUsed"); companyProduct.addError(companyProductDD.getField(COMPANY), "basic.company.message.companyIsAlreadyUsed"); return false; } return true; } boolean checkIfProductIsParticularProduct(final DataDefinition companyProductDD, final Entity companyProduct); boolean checkIfProductIsNotAlreadyUsed(final DataDefinition companyProductDD, final Entity companyProduct); boolean checkIfProductHasDefaultSupplier(final DataDefinition companyProductDD, final Entity companyProduct); }### Answer: @Ignore @Test public void shouldReturnTrueWhenCheckIfProductIsNotAlreadyUsed() { given(companyProductService.checkIfProductIsNotUsed(companyProduct, PRODUCT, COMPANY, PRODUCTS)).willReturn(true); boolean result = companyProductHooks.checkIfProductIsNotAlreadyUsed(companyProductDD, companyProduct); assertTrue(result); verify(companyProduct, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Ignore @Test public void shouldReturnFalseWhenCheckIfProductIsNotAlreadyUsed() { given(companyProductService.checkIfProductIsNotUsed(companyProduct, PRODUCT, COMPANY, PRODUCTS)).willReturn(false); boolean result = companyProductHooks.checkIfProductIsNotAlreadyUsed(companyProductDD, companyProduct); assertFalse(result); verify(companyProduct).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: WorkPlansColumnFiller implements ColumnFiller { @Override public Map<Entity, Map<String, String>> getOrderValues(final List<Entity> orders) { Map<Entity, Map<String, String>> values = new HashMap<Entity, Map<String, String>>(); for (Entity order : orders) { fillOrderNames(order, values); fillOrderNumbers(order, values); fillOrderPlannedEndDate(order, values); fillOrderPlannedQuantity(order, values); fillOrderProductNumbers(order, values); } return values; } @Override Map<Entity, Map<String, String>> getOrderValues(final List<Entity> orders); @Override Map<Entity, Map<String, String>> getValues(final List<Entity> orders); }### Answer: @Test public void shouldReturnCorrectColumnValuesForOrdersTable() { List<Entity> orders = Arrays.asList(order, order2); Map<Entity, Map<String, String>> orderValues = workPlansColumnFiller.getOrderValues(orders); assertEquals(2, orderValues.size()); assertEquals(5, orderValues.get(order).size()); assertEquals(5, orderValues.get(order2).size()); assertEquals("order", orderValues.get(order).get("orderName")); assertEquals("1234", orderValues.get(order).get("orderNumber")); assertEquals("product (123)", orderValues.get(order).get("productName")); assertEquals("11.00000 abc", orderValues.get(order).get("plannedQuantity")); }
### Question: SupplyParameterHooks { public boolean checkIfLocationIsWarehouse(final DataDefinition parameterDD, final Entity parameter) { Entity location = parameter.getBelongsToField(LOCATION); if ((location != null) && !isLocationIsWarehouse(location)) { parameter.addError(parameterDD.getField(LOCATION), "parameter.validate.global.error.locationIsNotWarehouse"); return false; } return true; } void setFieldsVisibleAndRequired(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void setFieldsVisibleAndRequired(final ViewDefinitionState view); boolean checkIfLocationIsWarehouse(final DataDefinition parameterDD, final Entity parameter); void onCreate(final DataDefinition dataDefinition, final Entity parameter); }### Answer: @Test public void shouldReturnTrueWhenCheckIfLocationIsWarehouse() { given(parameter.getBelongsToField(LOCATION)).willReturn(null); given(location.getStringField(TYPE)).willReturn(LocationType.WAREHOUSE.getStringValue()); boolean result = supplyParameterHooks.checkIfLocationIsWarehouse(parameterDD, parameter); Assert.assertTrue(result); verify(parameter, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Test public void shouldReturnFalseWhenCheckIfLocationIsWarehouse() { given(parameter.getBelongsToField(LOCATION)).willReturn(location); given(location.getStringField(TYPE)).willReturn(LocationType.CONTROL_POINT.getStringValue()); boolean result = supplyParameterHooks.checkIfLocationIsWarehouse(parameterDD, parameter); Assert.assertFalse(result); verify(parameter).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: DeliveredProductDetailsHooks { public void fillUnitFields(final ViewDefinitionState view) { List<String> unitNames = Lists.newArrayList("damagedQuantityUnit", "deliveredQuantityUnit", "orderedQuantityUnit"); List<String> additionalUnitNames = Lists.newArrayList("additionalQuantityUnit"); deliveriesService.fillUnitFields(view, DeliveredProductFields.PRODUCT, unitNames, additionalUnitNames); } void beforeRender(final ViewDefinitionState view); void fillUnitFields(final ViewDefinitionState view); void fillCurrencyFields(final ViewDefinitionState view); void fillOrderedQuantities(final ViewDefinitionState view); void fillConversion(final ViewDefinitionState view); BigDecimal getDefaultConversion(Entity product); void setDeliveredQuantityFieldRequired(final ViewDefinitionState view); void setAdditionalQuantityFieldRequired(final ViewDefinitionState view); static final String OPERATION; static final String OFFER; }### Answer: @Test public void shouldSetProductUnitWhenProductIsSelected() throws Exception { String unit = "szt"; when(productLookup.getEntity()).thenReturn(product); when(product.getStringField("unit")).thenReturn(unit); deliveredProductDetailsHooks.fillUnitFields(view); verify(deliveredUnitField).setFieldValue("szt"); verify(damagedUnitField).setFieldValue("szt"); verify(orderedUnitField).setFieldValue("szt"); } @Test public void shouldReturnWhenProductIsNull() throws Exception { when(productLookup.getEntity()).thenReturn(null); deliveredProductDetailsHooks.fillUnitFields(view); verify(deliveredUnitField).setFieldValue(""); verify(damagedUnitField).setFieldValue(""); verify(orderedUnitField).setFieldValue(""); }
### Question: DeliveredProductDetailsHooks { public void setDeliveredQuantityFieldRequired(final ViewDefinitionState view) { FieldComponent delivedQuantity = (FieldComponent) view.getComponentByReference(DeliveredProductFields.DELIVERED_QUANTITY); delivedQuantity.setRequired(true); delivedQuantity.requestComponentUpdateState(); } void beforeRender(final ViewDefinitionState view); void fillUnitFields(final ViewDefinitionState view); void fillCurrencyFields(final ViewDefinitionState view); void fillOrderedQuantities(final ViewDefinitionState view); void fillConversion(final ViewDefinitionState view); BigDecimal getDefaultConversion(Entity product); void setDeliveredQuantityFieldRequired(final ViewDefinitionState view); void setAdditionalQuantityFieldRequired(final ViewDefinitionState view); static final String OPERATION; static final String OFFER; }### Answer: @Test public void shouldSetRequiredOnDeliveredQuantityField() throws Exception { deliveredProductDetailsHooks.setDeliveredQuantityFieldRequired(view); verify(deliveredQuantityField).setRequired(true); }
### Question: CompanyProductsFamilyHooks { public boolean checkIfProductIsProductsFamily(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily) { if (!productService.checkIfProductEntityTypeIsCorrect(companyProductsFamily.getBelongsToField(PRODUCT), PRODUCTS_FAMILY)) { companyProductsFamily.addError(companyProductsFamilyDD.getField(PRODUCT), "basic.company.message.productIsNotProductsFamily"); return false; } return true; } boolean checkIfProductIsProductsFamily(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily); boolean checkIfProductsFamilyIsNotAlreadyUsed(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily); boolean checkIfProductHasDefaultSupplier(final DataDefinition companyProductDD, final Entity companyProduct); }### Answer: @Ignore @Test public void shouldReturnTrueWhenCheckIfProductIsProductsFamily() { given(companyProductsFamily.getBelongsToField(PRODUCT)).willReturn(product); given(productService.checkIfProductEntityTypeIsCorrect(product, PRODUCTS_FAMILY)).willReturn(true); boolean result = companyProductsFamilyHooks.checkIfProductIsProductsFamily(companyProductFamilyDD, companyProductsFamily); assertTrue(result); verify(companyProductsFamily, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Ignore @Test public void shouldReturnFalseWhenCheckIfProductIsProductsFamily() { given(companyProductsFamily.getBelongsToField(PRODUCT)).willReturn(product); given(productService.checkIfProductEntityTypeIsCorrect(product, PRODUCTS_FAMILY)).willReturn(false); boolean result = companyProductsFamilyHooks.checkIfProductIsProductsFamily(companyProductFamilyDD, companyProductsFamily); assertFalse(result); verify(companyProductsFamily).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: CompanyProductsFamilyHooks { public boolean checkIfProductsFamilyIsNotAlreadyUsed(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily) { if (!companyProductService.checkIfProductIsNotUsed(companyProductsFamily, PRODUCT, COMPANY, PRODUCTS_FAMILIES)) { companyProductsFamily.addError(companyProductsFamilyDD.getField(PRODUCT), "basic.company.message.productsFamilyIsAlreadyUsed"); companyProductsFamily.addError(companyProductsFamilyDD.getField(COMPANY), "basic.company.message.companyIsAlreadyUsed"); return false; } return true; } boolean checkIfProductIsProductsFamily(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily); boolean checkIfProductsFamilyIsNotAlreadyUsed(final DataDefinition companyProductsFamilyDD, final Entity companyProductsFamily); boolean checkIfProductHasDefaultSupplier(final DataDefinition companyProductDD, final Entity companyProduct); }### Answer: @Ignore @Test public void shouldReturnTrueWhenCheckIfProductsFamilyIsNotAlreadyUsed() { given(companyProductService.checkIfProductIsNotUsed(companyProductsFamily, PRODUCT, COMPANY, PRODUCTS_FAMILIES)) .willReturn(true); boolean result = companyProductsFamilyHooks.checkIfProductsFamilyIsNotAlreadyUsed(companyProductFamilyDD, companyProductsFamily); assertTrue(result); verify(companyProductsFamily, never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Ignore @Test public void shouldReturnFalseWhenCheckIfProductsFamilyIsNotAlreadyUsed() { given(companyProductService.checkIfProductIsNotUsed(companyProductsFamily, PRODUCT, COMPANY, PRODUCTS_FAMILIES)) .willReturn(false); boolean result = companyProductsFamilyHooks.checkIfProductsFamilyIsNotAlreadyUsed(companyProductFamilyDD, companyProductsFamily); assertFalse(result); verify(companyProductsFamily).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: DeliveriesColumnLoaderServiceImpl implements DeliveriesColumnLoaderService { public boolean isColumnsForDeliveriesEmpty() { return columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_DELIVERIES); } @Override void fillColumnsForDeliveries(final String plugin); @Override void clearColumnsForDeliveries(final String plugin); @Override void fillColumnsForOrders(final String plugin); @Override void clearColumnsForOrders(final String plugin); boolean isColumnsForDeliveriesEmpty(); boolean isColumnsForOrdersEmpty(); }### Answer: @Test public void shouldReturnTrueWhenIsColumnsForDeliveriesEmpty() { given( columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_DELIVERIES)).willReturn(true); boolean result = deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty(); assertTrue(result); } @Test public void shouldReturnFalseWhenIsColumnsForDeliveriesEmpty() { given( columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_DELIVERIES)).willReturn(false); boolean result = deliveriesColumnLoaderService.isColumnsForDeliveriesEmpty(); assertFalse(result); }
### Question: DeliveriesColumnLoaderServiceImpl implements DeliveriesColumnLoaderService { public boolean isColumnsForOrdersEmpty() { return columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_ORDERS); } @Override void fillColumnsForDeliveries(final String plugin); @Override void clearColumnsForDeliveries(final String plugin); @Override void fillColumnsForOrders(final String plugin); @Override void clearColumnsForOrders(final String plugin); boolean isColumnsForDeliveriesEmpty(); boolean isColumnsForOrdersEmpty(); }### Answer: @Test public void shouldReturnTrueWhenIsColumnsForOrdersEmpty() { given( columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_ORDERS)).willReturn(true); boolean result = deliveriesColumnLoaderService.isColumnsForOrdersEmpty(); assertTrue(result); } @Test public void shouldReturnFalseWhenIsColumnsForOrdersEmpty() { given( columnExtensionService.isColumnsEmpty(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_ORDERS)).willReturn(false); boolean result = deliveriesColumnLoaderService.isColumnsForOrdersEmpty(); assertFalse(result); }
### Question: DeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantEnable() { deliveriesColumnLoader.addColumnsForDeliveries(); deliveriesColumnLoader.addColumnsForOrders(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantEnable() { deliveriesOnStartupService.multiTenantEnable(); verify(deliveriesColumnLoader).addColumnsForDeliveries(); verify(deliveriesColumnLoader).addColumnsForOrders(); }
### Question: DeliveriesOnStartupService extends Module { @Transactional @Override public void multiTenantDisable() { deliveriesColumnLoader.deleteColumnsForDeliveries(); deliveriesColumnLoader.deleteColumnsForOrders(); } @Transactional @Override void multiTenantEnable(); @Transactional @Override void multiTenantDisable(); }### Answer: @Test public void shouldMultiTenantDisable() { deliveriesOnStartupService.multiTenantDisable(); verify(deliveriesColumnLoader).deleteColumnsForDeliveries(); verify(deliveriesColumnLoader).deleteColumnsForOrders(); }
### Question: WorkPlansColumnLoaderServiceImpl implements WorkPlansColumnLoaderService { public void fillColumnsForProducts(final String plugin) { Map<Integer, Map<String, String>> columnsAttributes = columnExtensionService.getColumnsAttributesFromXML(plugin, L_COLUMN_FOR_PRODUCTS); for (Map<String, String> columnAttributes : columnsAttributes.values()) { readData(L_COLUMN_FOR_PRODUCTS, OperationType.ADD, columnAttributes); } } void setParameterDefaultValues(); void fillColumnsForOrders(final String plugin); void clearColumnsForOrders(final String plugin); void fillColumnsForProducts(final String plugin); void clearColumnsForProducts(final String plugin); boolean isColumnsForOrdersEmpty(); boolean isColumnsForProductsEmpty(); }### Answer: @Ignore @Test public void shouldFillColumnsForProducts() { when(dataDefinitionService.get(WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_COLUMN_FOR_INPUT_PRODUCTS)) .thenReturn(columnForInputProductsDD); when(dataDefinitionService.get(WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_COLUMN_FOR_OUTPUT_PRODUCTS)) .thenReturn(columnForOutputProductsDD); workPlansColumnLoaderServiceImpl.fillColumnsForProducts("plugin"); }
### Question: WorkPlansColumnLoaderServiceImpl implements WorkPlansColumnLoaderService { public void clearColumnsForProducts(final String plugin) { Map<Integer, Map<String, String>> columnsAttributes = columnExtensionService.getColumnsAttributesFromXML(plugin, L_COLUMN_FOR_PRODUCTS); for (Map<String, String> columnAttributes : columnsAttributes.values()) { readData(L_COLUMN_FOR_PRODUCTS, OperationType.DELETE, columnAttributes); } } void setParameterDefaultValues(); void fillColumnsForOrders(final String plugin); void clearColumnsForOrders(final String plugin); void fillColumnsForProducts(final String plugin); void clearColumnsForProducts(final String plugin); boolean isColumnsForOrdersEmpty(); boolean isColumnsForProductsEmpty(); }### Answer: @Ignore @Test public void shouldClearColumnsForProducts() { when(dataDefinitionService.get(WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_COLUMN_FOR_INPUT_PRODUCTS)) .thenReturn(columnForInputProductsDD); when(dataDefinitionService.get(WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_COLUMN_FOR_OUTPUT_PRODUCTS)) .thenReturn(columnForOutputProductsDD); workPlansColumnLoaderServiceImpl.clearColumnsForProducts("plugin"); }
### Question: OrderHooksCNFM { public void fillOrderOperationProductsInComponents(final DataDefinition orderDD, final Entity order) { Entity technology = order.getBelongsToField(OrderFields.TECHNOLOGY); if (technology != null) { boolean shouldUpdate; if (order.getId() != null) { Entity orderFromDb = orderDD.get(order.getId()); shouldUpdate = orderFromDb.getBelongsToField(OrderFields.TECHNOLOGY) == null; } else { shouldUpdate = true; } if (shouldUpdate) { List<Entity> orderMaterialsCosts = orderMaterialsCostDataGenerator.generateUpdatedMaterialsListFor(order); order.setField(OrderFieldsCNFM.TECHNOLOGY_INST_OPER_PRODUCT_IN_COMPS, orderMaterialsCosts); } } } void fillOrderOperationProductsInComponents(final DataDefinition orderDD, final Entity order); }### Answer: @Test public final void shouldRunGenerator() { List<Entity> generatorResults = Lists.newArrayList(mockEntity(), mockEntity()); stubGeneratorResults(generatorResults); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(technology); given(orderFromDB.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(null); given(order.getId()).willReturn(1L); given(orderDD.get(1L)).willReturn(orderFromDB); orderHooksCNFM.fillOrderOperationProductsInComponents(orderDD, order); verify(order).setField(OrderFieldsCNFM.TECHNOLOGY_INST_OPER_PRODUCT_IN_COMPS, generatorResults); }
### Question: WorkPlansListHooks { public void setGridGenerateButtonState(final ViewDefinitionState viewDefinitionState) { setGridGenerateButtonState(WorkPlansListView.from(viewDefinitionState)); } void setGridGenerateButtonState(final ViewDefinitionState viewDefinitionState); void setGridGenerateButtonState(final WorkPlansListView view); }### Answer: @Test public final void shouldEnableDeleteButton() { stubGridSelectedEntities(mockWorkPlanEntity(false, OrderState.PENDING, OrderState.PENDING), mockWorkPlanEntity(false, OrderState.ACCEPTED, OrderState.COMPLETED), mockWorkPlanEntity(true, OrderState.ACCEPTED, OrderState.IN_PROGRESS)); workPlansListHooks.setGridGenerateButtonState(workPlansListView); verify(workPlansListView).setUpDeleteButton(true, null); } @Test public final void shouldDisableDeleteButtonWhenNoneEntityIsSelected() { stubGridSelectedEntities(); workPlansListHooks.setGridGenerateButtonState(workPlansListView); verify(workPlansListView).setUpDeleteButton(false, null); } @Test public final void shouldDisableDeleteButtonWhenAnyOfWorkPlansIsGeneratedAndRelatesToAtLeastOneCompletedOrder() { stubGridSelectedEntities(mockWorkPlanEntity(false, OrderState.PENDING, OrderState.PENDING, OrderState.COMPLETED), mockWorkPlanEntity(true, OrderState.ABANDONED, OrderState.COMPLETED)); workPlansListHooks.setGridGenerateButtonState(workPlansListView); verify(workPlansListView).setUpDeleteButton(false, "orders.ribbon.message.selectedRecordCannotBeDeleted"); }
### Question: ColumnExtensionServiceImpl implements ColumnExtensionService { public void deleteColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes) { final List<Entity> columns = getColumnDD(pluginIdentifier, model).find() .add(SearchRestrictions.eq(IDENTIFIER, columnAttributes.get(IDENTIFIER))).list().getEntities(); for (Entity column : columns) { column.getDataDefinition().delete(column.getId()); } } Map<Integer, Map<String, String>> getColumnsAttributesFromXML(final String plugin, final String file); Entity addColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes); void deleteColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes); boolean isColumnsEmpty(final String pluginIdentifier, final String model); @Override List<Entity> filterEmptyColumns(final List<Entity> columns, final List<Entity> rows, final Map<Entity, Map<String, String>> columnValues); }### Answer: @Test public void shouldDeleteColumn() { String pluginIdentifier = "plugin"; String model = "model"; entities = mockEntityList(Arrays.asList(entity)); given(dataDefinitionService.get(pluginIdentifier, model)).willReturn(entityDD); given(entityDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.add(Mockito.any(SearchCriterion.class))).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(entities); given(entity.getDataDefinition()).willReturn(entityDD); columnExtensionService.deleteColumn(pluginIdentifier, model, columnAttributes); verify(entityDD).delete(entity.getId()); }
### Question: ColumnExtensionServiceImpl implements ColumnExtensionService { public boolean isColumnsEmpty(final String pluginIdentifier, final String model) { return getColumnDD(pluginIdentifier, model).find().list().getTotalNumberOfEntities() == 0; } Map<Integer, Map<String, String>> getColumnsAttributesFromXML(final String plugin, final String file); Entity addColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes); void deleteColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes); boolean isColumnsEmpty(final String pluginIdentifier, final String model); @Override List<Entity> filterEmptyColumns(final List<Entity> columns, final List<Entity> rows, final Map<Entity, Map<String, String>> columnValues); }### Answer: @Test public void shouldReturnTrueWhenIsColumnsEmpty() { String pluginIdentifier = "plugin"; String model = "model"; given(dataDefinitionService.get(pluginIdentifier, model)).willReturn(entityDD); given(entityDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.list()).willReturn(searchResult); given(searchResult.getTotalNumberOfEntities()).willReturn(0); boolean result = columnExtensionService.isColumnsEmpty(pluginIdentifier, model); Assert.assertTrue(result); } @Test public void shouldReturnFalseWhenIsColumnsEmpty() { String pluginIdentifier = "plugin"; String model = "model"; given(dataDefinitionService.get(pluginIdentifier, model)).willReturn(entityDD); given(entityDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.list()).willReturn(searchResult); given(searchResult.getTotalNumberOfEntities()).willReturn(1); boolean result = columnExtensionService.isColumnsEmpty(pluginIdentifier, model); Assert.assertFalse(result); }
### Question: WorkPlanHooks { public void onCopy(final DataDefinition workPlanDD, final Entity workPlan) { clearGeneratedOnCopy(workPlan); } void onCreate(final DataDefinition workPlanDD, final Entity workPlan); void onCopy(final DataDefinition workPlanDD, final Entity workPlan); }### Answer: @Test public void shouldClearGeneratedOnCopy() { workPlanHooks.onCopy(workPlanDD, workPlan); verify(workPlan).setField(WorkPlanFields.FILE_NAME, null); verify(workPlan).setField(WorkPlanFields.GENERATED, false); verify(workPlan).setField(WorkPlanFields.DATE, null); verify(workPlan).setField(WorkPlanFields.WORKER, null); }
### Question: LineChangeoverNormsDetailsHooks { public void setFieldsVisibleAndRequired(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { setFieldsVisibleAndRequired(view); } final void onBeforeRender(final ViewDefinitionState view); void setLineChangeoverNormsName(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void setFieldsVisibleAndRequired(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void setFieldsVisibleAndRequired(final ViewDefinitionState view); }### Answer: @Test public void shouldSetFieldsVisibleAndRequiredWhenChangeoverTypeIsForTechnology() { given(changeoverType.getFieldValue()).willReturn(FOR_TECHNOLOGY.getStringValue()); hooks.setFieldsVisibleAndRequired(view, null, null); verify(fromTechnology).setVisible(true); verify(fromTechnology).setRequired(true); verify(toTechnology).setVisible(true); verify(toTechnology).setRequired(true); verify(fromTechnologyGroup).setVisible(false); verify(fromTechnologyGroup).setRequired(false); verify(fromTechnologyGroup).setFieldValue(null); verify(toTechnologyGroup).setVisible(false); verify(toTechnologyGroup).setRequired(false); verify(toTechnologyGroup).setFieldValue(null); } @Test public void shouldSetFieldsVisibleAndRequiredWhenChangeoverTypeIsForTechnologyGroup() { given(changeoverType.getFieldValue()).willReturn(FOR_TECHNOLOGY_GROUP.getStringValue()); hooks.setFieldsVisibleAndRequired(view, null, null); verify(fromTechnology).setVisible(false); verify(fromTechnology).setRequired(false); verify(fromTechnology).setFieldValue(null); verify(toTechnology).setVisible(false); verify(toTechnology).setRequired(false); verify(toTechnology).setFieldValue(null); verify(fromTechnologyGroup).setVisible(true); verify(fromTechnologyGroup).setRequired(true); verify(toTechnologyGroup).setVisible(true); verify(toTechnologyGroup).setRequired(true); }
### Question: DraftDocumentsNotificationService { public boolean shouldNotifyCurrentUser() { Long currentUserId = securityService.getCurrentUserId(); return currentUserId != null && securityService.hasCurrentUserRole(ROLE_DOCUMENTS_NOTIFICATION) && countDraftDocumentsForUser(currentUserId) > 0; } @Autowired DraftDocumentsNotificationService(SecurityService securityService, DataDefinitionService dataDefinitionService); boolean shouldNotifyCurrentUser(); }### Answer: @Test public void shouldReturnFalseWhenUserNotLoggedIn() { given(securityService.getCurrentUserId()).willReturn(null); boolean result = draftDocumentsNotificationService.shouldNotifyCurrentUser(); verify(securityService).getCurrentUserId(); verify(securityService, never()).hasCurrentUserRole(ROLE_DOCUMENTS_NOTIFICATION); assertFalse(result); } @Test public void shouldReturnFalseWhenUserHasNoRole() { given(securityService.getCurrentUserId()).willReturn(CURRENT_USER_ID); given(securityService.hasCurrentUserRole(ROLE_DOCUMENTS_NOTIFICATION)).willReturn(Boolean.FALSE); boolean result = draftDocumentsNotificationService.shouldNotifyCurrentUser(); verify(securityService).getCurrentUserId(); verify(securityService).hasCurrentUserRole(ROLE_DOCUMENTS_NOTIFICATION); assertFalse(result); }
### Question: ProductsFamiliesListeners { public final void enabledEditButton(final ViewDefinitionState view, final ComponentState state, final String[] args) { setEditButtonEnabled(view, true); } final void generateHierarchyTree(final ViewDefinitionState view, final ComponentState state, final String[] args); final void editSelectedProduct(final ViewDefinitionState view, final ComponentState state, final String[] args); final void enabledEditButton(final ViewDefinitionState view, final ComponentState state, final String[] args); }### Answer: @Test public void shouldEnabledButtonWhenProductOnTreeIsSelected() throws Exception { when(view.getComponentByReference("window")).thenReturn((ComponentState) windowComponent); when(windowComponent.getRibbon()).thenReturn(ribbon); when(ribbon.getGroupByName("edit")).thenReturn(ribbonGroup); when(ribbonGroup.getItemByName("editSelectedProduct")).thenReturn(actionItem); productsFamiliesListeners.enabledEditButton(view, state, new String[0]); Mockito.verify(actionItem).setEnabled(true); }
### Question: BasicController { @RequestMapping(value = "parameters", method = RequestMethod.GET) public ModelAndView getParameterPageView(final Locale locale) { JSONObject json = new JSONObject(ImmutableMap.of("form.id", parameterService.getParameterId().toString())); Map<String, String> arguments = ImmutableMap.of("context", json.toString()); return crudService.prepareView(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.VIEW_PARAMETERS, arguments, locale); } @RequestMapping(value = "parameters", method = RequestMethod.GET) ModelAndView getParameterPageView(final Locale locale); }### Answer: @Test public void shouldPrepareViewForParameters() throws Exception { Map<String, String> arguments = ImmutableMap.of("context", "{\"form.id\":\"13\"}"); ModelAndView expectedMav = mock(ModelAndView.class); CrudService crudController = mock(CrudService.class); given( crudController.prepareView(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.VIEW_PARAMETERS, arguments, Locale.ENGLISH)).willReturn(expectedMav); ParameterService parameterService = mock(ParameterService.class); given(parameterService.getParameterId()).willReturn(13L); BasicController basicController = new BasicController(); setField(basicController, "crudService", crudController); setField(basicController, "parameterService", parameterService); ModelAndView mav = basicController.getParameterPageView(Locale.ENGLISH); assertEquals(expectedMav, mav); }
### Question: ProductDetailsHooks { public void fillUnit(final ViewDefinitionState view) { FormComponent productForm = (FormComponent) view.getComponentByReference(L_FORM); FieldComponent unitField = (FieldComponent) view.getComponentByReference(UNIT); if ((productForm.getEntityId() == null) && (unitField.getFieldValue() == null)) { unitField.setFieldValue(unitService.getDefaultUnitFromSystemParameters()); unitField.requestComponentUpdateState(); } } void generateProductNumber(final ViewDefinitionState view); void fillUnit(final ViewDefinitionState view); void disableUnitFromWhenFormIsSaved(final ViewDefinitionState view); void disableProductFormForExternalItems(final ViewDefinitionState state); void updateRibbonState(final ViewDefinitionState view); }### Answer: @Test public void shouldntFillUnitIfFormIsSaved() { given(view.getComponentByReference(L_FORM)).willReturn(productForm); given(view.getComponentByReference(UNIT)).willReturn(unitField); given(productForm.getEntityId()).willReturn(L_ID); productDetailsHooks.fillUnit(view); verify(unitField, never()).setFieldValue(Mockito.anyString()); } @Test public void shouldFillUnitIfFormIsntSaved() { given(view.getComponentByReference(L_FORM)).willReturn(productForm); given(view.getComponentByReference(UNIT)).willReturn(unitField); given(productForm.getEntityId()).willReturn(null); given(unitField.getFieldValue()).willReturn(null); given(unitService.getDefaultUnitFromSystemParameters()).willReturn(L_SZT); productDetailsHooks.fillUnit(view); verify(unitField).setFieldValue(L_SZT); }
### Question: WorkPlansListView { public List<Entity> getSelectedWorkPlans() { return workPlansGrid.getSelectedEntities(); } WorkPlansListView(final WindowComponent window, final RibbonActionItem deleteButton, final GridComponent workPlansGrid); static WorkPlansListView from(final ViewDefinitionState view); void setUpDeleteButton(final boolean isEnabled, final String message); List<Entity> getSelectedWorkPlans(); @Override boolean equals(final Object obj); @Override int hashCode(); }### Answer: @Test public final void shouldGetSelectedEntities() { List<Entity> entities = ImmutableList.of(mockEntity(), mockEntity(), mockEntity(), mockEntity()); given(workPlansGrid.getSelectedEntities()).willReturn(entities); List<Entity> result = workPlansListView.getSelectedWorkPlans(); assertEquals(entities, result); }
### Question: UnitConversionItemValidatorsB { public boolean validateUnitOnConversionWithProduct(final DataDefinition dataDefinition, final Entity unitConversionItem) { final Entity product = unitConversionItem.getBelongsToField(UnitConversionItemFieldsB.PRODUCT); final String unitFrom = unitConversionItem.getStringField(UnitConversionItemFields.UNIT_FROM); if (product == null || product.getStringField(ProductFields.UNIT).equals(unitFrom)) { return true; } final String errorMsg = "basic.product.validateError.unitFrom.doesNotMatchUnitConversionItem"; unitConversionItem.addError(dataDefinition.getField(UnitConversionItemFields.UNIT_FROM), errorMsg); return false; } boolean validateUnitOnConversionWithProduct(final DataDefinition dataDefinition, final Entity unitConversionItem); }### Answer: @Test public void sholudReturnTrueIfProductIsNull() { given(unitConversionItem.getBelongsToField(UnitConversionItemFieldsB.PRODUCT)).willReturn(null); boolean result = unitConversionItemValidatorsB.validateUnitOnConversionWithProduct(dataDefinition, unitConversionItem); assertTrue(result); } @Test public void sholudReturnTrueIfProductUnitIsEqualFieldUnit() { stubConversionSourceUnit(SOME_UNIT); stubProductUnit(SOME_UNIT); boolean result = unitConversionItemValidatorsB.validateUnitOnConversionWithProduct(dataDefinition, unitConversionItem); assertTrue(result); verify(unitConversionItem, Mockito.never()).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); } @Test public void sholudReturnErrorIfProductUnitIsNotEqualFieldUnit() { stubConversionSourceUnit(SOME_UNIT); stubProductUnit("otherNotEqualSzt"); boolean result = unitConversionItemValidatorsB.validateUnitOnConversionWithProduct(dataDefinition, unitConversionItem); assertFalse(result); verify(unitConversionItem).addError(Mockito.any(FieldDefinition.class), Mockito.anyString()); }
### Question: ProductHooks { public void clearExternalIdOnCopy(final DataDefinition dataDefinition, final Entity entity) { if (entity == null) { return; } entity.setField("externalNumber", null); } void generateNodeNumber(final DataDefinition productDD, final Entity product); void updateNodeNumber(final DataDefinition productDD, final Entity product); void clearFamilyFromProductWhenTypeIsChanged(final DataDefinition productDD, final Entity product); boolean checkIfNotBelongsToSameFamily(final DataDefinition productDD, final Entity product); boolean checkIfParentIsFamily(final DataDefinition productDD, final Entity product); void clearFieldsOnCopy(final DataDefinition dataDefinition, final Entity product); void clearExternalIdOnCopy(final DataDefinition dataDefinition, final Entity entity); void calculateConversionIfUnitChanged(final DataDefinition productDD, final Entity product); void calculateConversionOnCreate(final DataDefinition productDD, final Entity product); boolean validateAdditionalUnit(final DataDefinition productDD, final Entity product); boolean validateCodeUniqueness(final DataDefinition productDD, final Entity product); }### Answer: @Test public void shouldClearExternalIdOnCopy() throws Exception { productHooks.clearExternalIdOnCopy(dataDefinition, entity); Mockito.verify(entity).setField("externalNumber", null); }
### Question: WorkPlansListView { public void setUpDeleteButton(final boolean isEnabled, final String message) { deleteButton.setEnabled(isEnabled); deleteButton.setMessage(message); deleteButton.requestUpdate(true); window.requestRibbonRender(); } WorkPlansListView(final WindowComponent window, final RibbonActionItem deleteButton, final GridComponent workPlansGrid); static WorkPlansListView from(final ViewDefinitionState view); void setUpDeleteButton(final boolean isEnabled, final String message); List<Entity> getSelectedWorkPlans(); @Override boolean equals(final Object obj); @Override int hashCode(); }### Answer: @Test public final void shouldSetUpDeleteButton() { boolean isEnabled = true; String message = "some arbitrary mesage"; workPlansListView.setUpDeleteButton(isEnabled, message); verify(deleteButton).setEnabled(isEnabled); verify(deleteButton).setMessage(message); verify(deleteButton).requestUpdate(true); verify(windowComponent).requestRibbonRender(); }
### Question: CompanyService { public Long getCompanyId() { if (getCompany() == null) { return null; } else { return getCompany().getId(); } } Long getCompanyId(); @Transactional Entity getCompany(); @Transactional Entity getCompany(final Long companyId); final Boolean isCompanyOwner(final Entity company); void disabledGridWhenCompanyIsOwner(final ViewDefinitionState view, final String... references); void disableButton(final ViewDefinitionState view, final String ribbonGroupName, final String ribbonActionItemName, final boolean isEnabled, final String message); }### Answer: @Test public void shouldReturnExistingCompanyEntityId() throws Exception { Entity company = Mockito.mock(Entity.class); given(company.getId()).willReturn(13L); given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBelongsToField(ParameterFields.COMPANY)).willReturn(company); Long id = companyService.getCompanyId(); assertEquals(Long.valueOf(13L), id); }
### Question: CompanyService { @Transactional public Entity getCompany() { Entity parameter = parameterService.getParameter(); return parameter.getBelongsToField(ParameterFields.COMPANY); } Long getCompanyId(); @Transactional Entity getCompany(); @Transactional Entity getCompany(final Long companyId); final Boolean isCompanyOwner(final Entity company); void disabledGridWhenCompanyIsOwner(final ViewDefinitionState view, final String... references); void disableButton(final ViewDefinitionState view, final String ribbonGroupName, final String ribbonActionItemName, final boolean isEnabled, final String message); }### Answer: @Test public void shouldReturnExistingCompanyEntity() throws Exception { given(parameterService.getParameter()).willReturn(parameter); given(parameter.getBelongsToField(ParameterFields.COMPANY)).willReturn(company); given(company.isValid()).willReturn(true); Entity existingcompany = companyService.getCompany(); assertEquals(company, existingcompany); }
### Question: WorkingHours implements Comparable<WorkingHours> { public Set<TimeRange> getTimeRanges() { return Collections.unmodifiableSet(hours); } WorkingHours(final String hourRanges); boolean isEmpty(); boolean contains(final LocalTime time); Optional<TimeRange> findRangeFor(final LocalTime time); Set<TimeRange> getTimeRanges(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(final WorkingHours other); }### Answer: @Test public final void shouldBuildWorkingHoursFromSingleTimeRangeWithTwoDigitsHour() { String timeRangeString = "09:00-17:00"; WorkingHours workingHours = new WorkingHours(timeRangeString); assertEquals(1, workingHours.getTimeRanges().size()); TimeRange timeRange = workingHours.getTimeRanges().iterator().next(); assertEquals(new LocalTime(9, 0, 0), timeRange.getFrom()); assertEquals(new LocalTime(17, 0, 0), timeRange.getTo()); } @Test public final void shouldBuildWorkingHoursFromSingleTimeRangeWithOneDigitsHour() { String timeRangeString = "9:00-17:00"; WorkingHours workingHours = new WorkingHours(timeRangeString); assertEquals(1, workingHours.getTimeRanges().size()); TimeRange timeRange = workingHours.getTimeRanges().iterator().next(); assertEquals(new LocalTime(9, 0, 0), timeRange.getFrom()); assertEquals(new LocalTime(17, 0, 0), timeRange.getTo()); }
### Question: ProductsFamiliesTreeService { public List<Entity> getHierarchyProductsTree(final Entity product) { List<Entity> tree = new ArrayList<Entity>(); addProduct(tree, product); generateTree(product, tree); return tree; } List<Entity> getHierarchyProductsTree(final Entity product); }### Answer: @Test public void shouldReturnTreeWithoutChildrenWhenDoesnotExists() throws Exception { EntityList emptyList = mockEntityList(new LinkedList<Entity>()); when(productDsk.getHasManyField(PRODUCT_FAMILY_CHILDRENS)).thenReturn(emptyList); List<Entity> tree = productsFamiliesTreeService.getHierarchyProductsTree(productDsk); assertEquals(1, tree.size()); assertEquals(productDsk, tree.get(0)); } @Test public void shouldReturnTreeWithTwoLevel() throws Exception { List<Entity> tree = productsFamiliesTreeService.getHierarchyProductsTree(productDsk); assertEquals(4, tree.size()); assertEquals(productDsk3, tree.get(2)); assertEquals(productDsk2, tree.get(3)); } @Test public void shouldReturnTreeWithOneLevel() throws Exception { EntityList emptyList = mockEntityList(new LinkedList<Entity>()); when(productDsk1.getHasManyField(PRODUCT_FAMILY_CHILDRENS)).thenReturn(emptyList); List<Entity> tree = productsFamiliesTreeService.getHierarchyProductsTree(productDsk); assertEquals(3, tree.size()); assertEquals(productDsk2, tree.get(2)); }
### Question: ProductCatalogNumbersServiceImpl implements ProductCatalogNumbersService { @Override public Entity getProductCatalogNumber(final Entity product, final Entity supplier) { return dataDefinitionService .get(ProductCatalogNumbersConstants.PLUGIN_IDENTIFIER, ProductCatalogNumbersConstants.MODEL_PRODUCT_CATALOG_NUMBERS).find() .add(SearchRestrictions.belongsTo(PRODUCT, product)).add(SearchRestrictions.belongsTo(COMPANY, supplier)) .setMaxResults(1).uniqueResult(); } @Override Entity getProductCatalogNumber(final Entity product, final Entity supplier); }### Answer: @Test public void shouldReturnNullWhenGetProductCatalogNumber() { given(productCatalogNumbersDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.add(Mockito.any(SearchCriterion.class))).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.setMaxResults(1)).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.uniqueResult()).willReturn(null); Entity result = productCatalogNumbersService.getProductCatalogNumber(null, null); assertEquals(null, result); } @Test public void shouldReturnProductCatalogNumberWhenFetProductCatalogNumber() { given(productCatalogNumbersDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.add(Mockito.any(SearchCriterion.class))).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.setMaxResults(1)).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.uniqueResult()).willReturn(productCatalogNumbers); Entity result = productCatalogNumbersService.getProductCatalogNumber(product, supplier); assertEquals(productCatalogNumbers, result); }
### Question: ProductService { public boolean checkIfProductEntityTypeIsCorrect(final Entity product, final ProductFamilyElementType entityType) { return entityType.getStringValue().equals(product.getStringField(ENTITY_TYPE)); } Entity find(final SearchProjection projection, final SearchCriterion criteria, final SearchOrder order); List<Entity> findAll(final SearchProjection projection, final SearchCriterion criteria, final SearchOrder order); boolean checkIfProductEntityTypeIsCorrect(final Entity product, final ProductFamilyElementType entityType); void conversionForProductUnit(final Entity product); BigDecimal convertQuantityFromProductUnit(final Entity product, final BigDecimal quantity, final String targetUnit); boolean hasUnitChangedOnUpdate(final Entity product); void getDefaultConversions(final ViewDefinitionState view, final ComponentState state, final String[] args); void getDefaultConversionsForGrid(final ViewDefinitionState view, final ComponentState state, final String[] args); boolean checkIfSubstituteIsNotRemoved(final DataDefinition substituteComponentDD, final Entity substituteComponent); boolean checkSubstituteComponentUniqueness(final DataDefinition substituteComponentDD, final Entity substituteComponent); boolean checkIfProductIsNotRemoved(final DataDefinition substituteDD, final Entity substitute); void fillUnit(final DataDefinition productDD, final Entity product); }### Answer: @Test public void shouldReturnTrueWhenCheckIfProductEntityTypeIsCorrect() throws Exception { given(product.getStringField(ENTITY_TYPE)).willReturn(PARTICULAR_PRODUCT.getStringValue()); boolean result = productService.checkIfProductEntityTypeIsCorrect(product, PARTICULAR_PRODUCT); assertTrue(result); } @Test public void shouldReturnFalseWhenCheckIfProductEntityTypeIsCorrect() throws Exception { given(product.getStringField(ENTITY_TYPE)).willReturn(PARTICULAR_PRODUCT.getStringValue()); boolean result = productService.checkIfProductEntityTypeIsCorrect(product, PRODUCTS_FAMILY); assertFalse(result); }
### Question: ProductService { public void fillUnit(final DataDefinition productDD, final Entity product) { if (product.getField(UNIT) == null) { product.setField(UNIT, unitService.getDefaultUnitFromSystemParameters()); } } Entity find(final SearchProjection projection, final SearchCriterion criteria, final SearchOrder order); List<Entity> findAll(final SearchProjection projection, final SearchCriterion criteria, final SearchOrder order); boolean checkIfProductEntityTypeIsCorrect(final Entity product, final ProductFamilyElementType entityType); void conversionForProductUnit(final Entity product); BigDecimal convertQuantityFromProductUnit(final Entity product, final BigDecimal quantity, final String targetUnit); boolean hasUnitChangedOnUpdate(final Entity product); void getDefaultConversions(final ViewDefinitionState view, final ComponentState state, final String[] args); void getDefaultConversionsForGrid(final ViewDefinitionState view, final ComponentState state, final String[] args); boolean checkIfSubstituteIsNotRemoved(final DataDefinition substituteComponentDD, final Entity substituteComponent); boolean checkSubstituteComponentUniqueness(final DataDefinition substituteComponentDD, final Entity substituteComponent); boolean checkIfProductIsNotRemoved(final DataDefinition substituteDD, final Entity substitute); void fillUnit(final DataDefinition productDD, final Entity product); }### Answer: @Test public void shouldntFillUnitIfUnitIsntNull() { Entity product = mock(Entity.class); DataDefinition productDD = mock(DataDefinition.class); given(product.getField(UNIT)).willReturn(L_SZT); productService.fillUnit(productDD, product); verify(product, never()).setField(Mockito.anyString(), Mockito.anyString()); } @Test public void shouldFillUnitIfUnitIsNull() { Entity product = mock(Entity.class); DataDefinition productDD = mock(DataDefinition.class); given(product.getField(UNIT)).willReturn(null); given(unitService.getDefaultUnitFromSystemParameters()).willReturn(L_SZT); productService.fillUnit(productDD, product); verify(product).setField(UNIT, L_SZT); }
### Question: OperationalTaskValidatorsOTFO { public boolean validatesWith(final DataDefinition operationalTaskDD, final Entity operationalTask) { return checkIfOrderHasTechnology(operationalTaskDD, operationalTask); } boolean validatesWith(final DataDefinition operationalTaskDD, final Entity operationalTask); }### Answer: @Test public void shouldReturnTrueWhenOrderIsNotSave() throws Exception { given(operationalTask.getBelongsToField(OperationalTaskFieldsOTFO.ORDER)).willReturn(null); boolean result = operationalTaskValidatorsOTFO.validatesWith(operationalTaskDD, operationalTask); Assert.assertTrue(result); } @Test public void shouldReturnFalseWhenOrderDoesNotHaveTechnology() throws Exception { given(operationalTask.getBelongsToField(OperationalTaskFieldsOTFO.ORDER)).willReturn(order); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(null); boolean result = operationalTaskValidatorsOTFO.validatesWith(operationalTaskDD, operationalTask); Assert.assertFalse(result); Mockito.verify(operationalTask).addError(operationalTaskDD.getField(OperationalTaskFieldsOTFO.ORDER), "operationalTasks.operationalTask.order.error.technologyIsNull"); } @Test public void shouldReturnTrueWhenOrderHaveTechnology() throws Exception { when(operationalTask.getBelongsToField(OperationalTaskFieldsOTFO.ORDER)).thenReturn(order); when(order.getBelongsToField(OrderFields.TECHNOLOGY)).thenReturn(technology); boolean result = operationalTaskValidatorsOTFO.validatesWith(operationalTaskDD, operationalTask); Assert.assertTrue(result); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public final void fillPreviousOrderForm(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { lineChangeoverNormsForOrdersService.fillOrderForm(view, LineChangeoverNormsForOrdersConstants.PREVIOUS_ORDER_FIELDS); } final void showPreviousOrder(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showBestFittingLineChangeoverNorm(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showLineChangeoverNormForGroup(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showLineChangeoverNormForTechnology(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void checkIfOrderHasCorrectStateAndIsPrevious(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void fillPreviousOrderForm(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void showOwnLineChangeoverDurationField(final ViewDefinitionState view, final ComponentState componentState, final String[] args); }### Answer: @Test public final void shouldFillPreviousOrderForm() { lineChangeoverNormsForOrderDetailsListeners.fillPreviousOrderForm(view, null, null); verify(lineChangeoverNormsForOrdersService).fillOrderForm(view, PREVIOUS_ORDER_FIELDS); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public void showOwnLineChangeoverDurationField(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { orderService.changeFieldState(view, OrderFieldsLCNFO.OWN_LINE_CHANGEOVER, OrderFieldsLCNFO.OWN_LINE_CHANGEOVER_DURATION); } final void showPreviousOrder(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showBestFittingLineChangeoverNorm(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showLineChangeoverNormForGroup(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void showLineChangeoverNormForTechnology(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void checkIfOrderHasCorrectStateAndIsPrevious(final ViewDefinitionState view, final ComponentState componentState, final String[] args); final void fillPreviousOrderForm(final ViewDefinitionState view, final ComponentState componentState, final String[] args); void showOwnLineChangeoverDurationField(final ViewDefinitionState view, final ComponentState componentState, final String[] args); }### Answer: @Test public void shouldShowOwnLineChangeoverDurationField() { lineChangeoverNormsForOrderDetailsListeners.showOwnLineChangeoverDurationField(view, null, null); verify(orderService).changeFieldState(view, OWN_LINE_CHANGEOVER, OWN_LINE_CHANGEOVER_DURATION); }
### Question: OrderDetailsListenersLCNFO { public final void showChangeover(final ViewDefinitionState viewState, final ComponentState componentState, final String[] args) { Long orderId = (Long) componentState.getFieldValue(); if (orderId == null) { return; } Map<String, Object> parameters = Maps.newHashMap(); parameters.put("form.id", orderId); String url = "/page/lineChangeoverNormsForOrders/lineChangeoverNormsForOrderDetails.html"; viewState.redirectTo(url, false, true, parameters); } final void showChangeover(final ViewDefinitionState viewState, final ComponentState componentState, final String[] args); }### Answer: @Test public void shouldntShowChangeoverIfOrderIdIsNull() { given(componentState.getFieldValue()).willReturn(null); String url = "/page/lineChangeoverNormsForOrders/lineChangeoverNormsForOrderDetails.html"; orderDetailsListenersLCNFO.showChangeover(view, componentState, null); verify(view, never()).redirectTo(url, false, true, parameters); } @Test public void shouldShowChangeoverIfOrderIdIsntNull() { given(componentState.getFieldValue()).willReturn(L_ID); parameters.put("form.id", L_ID); String url = "/page/lineChangeoverNormsForOrders/lineChangeoverNormsForOrderDetails.html"; orderDetailsListenersLCNFO.showChangeover(view, componentState, null); verify(view).redirectTo(url, false, true, parameters); }
### Question: OrderModelValidatorsLCNFO { public final boolean checkIfOrderHasCorrectStateAndIsPrevious(final DataDefinition orderDD, final Entity order) { Entity previousOrderDB = order.getBelongsToField(OrderFieldsLCNFO.PREVIOUS_ORDER); Entity orderDB = order.getBelongsToField(OrderFieldsLCNFO.ORDER); if (!lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(previousOrderDB, orderDB)) { order.addError(orderDD.getField(OrderFieldsLCNFO.PREVIOUS_ORDER), "orders.order.previousOrder.message.orderIsIncorrect"); return false; } return true; } final boolean checkIfOrderHasCorrectStateAndIsPrevious(final DataDefinition orderDD, final Entity order); }### Answer: @Test public void shouldReturnFalseWhenPreviousOrderIsNotCorrect() { given(lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(previousOrderDB, orderDB)).willReturn( false); boolean result = orderModelValidatorsLCNFO.checkIfOrderHasCorrectStateAndIsPrevious(orderDD, order); assertFalse(result); verify(order).addError(Mockito.eq(orderDD.getField(PREVIOUS_ORDER)), Mockito.anyString()); } @Test public void shouldReturnTrueWhenPreviousOrderIsCorrect() { given(lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(previousOrderDB, orderDB)).willReturn( true); boolean result = orderModelValidatorsLCNFO.checkIfOrderHasCorrectStateAndIsPrevious(orderDD, order); assertTrue(result); verify(order, never()).addError(Mockito.eq(orderDD.getField(PREVIOUS_ORDER)), Mockito.anyString()); }
### Question: LineChangeoverNormsForOrderDetailsViewHooks { public void showOwnLineChangeoverDurationField(final ViewDefinitionState view) { orderService.changeFieldState(view, OrderFieldsLCNFO.OWN_LINE_CHANGEOVER, OrderFieldsLCNFO.OWN_LINE_CHANGEOVER_DURATION); } final void fillOrderForms(final ViewDefinitionState view); void fillLineChangeoverNorm(final ViewDefinitionState view); void updateRibbonState(final ViewDefinitionState view); void showOwnLineChangeoverDurationField(final ViewDefinitionState view); }### Answer: @Test public void shouldShowOwnLineChangeoverDurationField() { lineChangeoverNormsForOrderDetailsViewHooks.showOwnLineChangeoverDurationField(view); verify(orderService).changeFieldState(view, OWN_LINE_CHANGEOVER, OWN_LINE_CHANGEOVER_DURATION); }
### Question: MasterOrderHooks { protected void setExternalSynchronizedField(final Entity masterOrder) { masterOrder.setField(MasterOrderFields.EXTERNAL_SYNCHRONIZED, true); } void onCreate(final DataDefinition dataDefinition, final Entity masterOrder); void onSave(final DataDefinition dataDefinition, final Entity masterOrder); void onUpdate(final DataDefinition dataDefinition, final Entity masterOrder); void onCopy(final DataDefinition dataDefinition, final Entity masterOrder); }### Answer: @Test public final void shouldSetExternalSynchronized() { masterOrderHooks.setExternalSynchronizedField(masterOrder); verify(masterOrder).setField(MasterOrderFields.EXTERNAL_SYNCHRONIZED, true); }
### Question: MasterOrderProductDetailsHooks { public void fillUnitField(final ViewDefinitionState view) { LookupComponent productField = (LookupComponent) view.getComponentByReference(MasterOrderProductFields.PRODUCT); Entity product = productField.getEntity(); String unit = null; if (product != null) { unit = product.getStringField(ProductFields.UNIT); } for (String reference : Arrays.asList("cumulatedOrderQuantityUnit", "masterOrderQuantityUnit", "producedOrderQuantityUnit", "leftToReleaseUnit")) { FieldComponent field = (FieldComponent) view.getComponentByReference(reference); field.setFieldValue(unit); field.requestComponentUpdateState(); } } void fillUnitField(final ViewDefinitionState view); void fillDefaultTechnology(final ViewDefinitionState view); void showErrorWhenCumulatedQuantity(final ViewDefinitionState view); }### Answer: @Test public final void shouldSetNullWhenProductDoesnotExists() { given(productField.getEntity()).willReturn(null); masterOrderProductDetailsHooks.fillUnitField(view); verify(cumulatedOrderQuantityUnitField).setFieldValue(null); verify(masterOrderQuantityUnitField).setFieldValue(null); verify(producedOrderQuantityUnitField).setFieldValue(null); } @Test public final void shouldSetUnitFromProduct() { String unit = "szt"; given(productField.getEntity()).willReturn(product); given(product.getStringField(ProductFields.UNIT)).willReturn(unit); masterOrderProductDetailsHooks.fillUnitField(view); verify(cumulatedOrderQuantityUnitField).setFieldValue(unit); verify(masterOrderQuantityUnitField).setFieldValue(unit); verify(producedOrderQuantityUnitField).setFieldValue(unit); }