Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### 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: OrderedProductHooks { public boolean checkIfOrderedProductAlreadyExists(final DataDefinition orderedProductDD, final Entity orderedProduct) { SearchCriteriaBuilder searchCriteriaBuilder = orderedProductDD.find() .add(SearchRestrictions.belongsTo(OrderedProductFields.DELIVERY, orderedProduct.getBelongsToField(OrderedProductFields.DELIVERY))) .add(SearchRestrictions.belongsTo(OrderedProductFields.PRODUCT, orderedProduct.getBelongsToField(OrderedProductFields.PRODUCT))) .add(SearchRestrictions.belongsTo(OrderedProductFields.ADDITIONAL_CODE, orderedProduct.getBelongsToField(OrderedProductFields.ADDITIONAL_CODE))); if(PluginUtils.isEnabled("techSubcontrForDeliveries")) { searchCriteriaBuilder.add(SearchRestrictions.belongsTo(OPERATION, orderedProduct.getBelongsToField(OPERATION))); } if(PluginUtils.isEnabled("supplyNegotiations")) { searchCriteriaBuilder.add(SearchRestrictions.belongsTo(OFFER, orderedProduct.getBelongsToField(OFFER))); } if (orderedProduct.getId() != null) { searchCriteriaBuilder.add(SearchRestrictions.ne("id", orderedProduct.getId())); } Entity orderedProductFromDB = searchCriteriaBuilder.setMaxResults(1).uniqueResult(); if (orderedProductFromDB == null) { return true; } else { orderedProduct.addError(orderedProductDD.getField(OrderedProductFields.PRODUCT), "deliveries.orderedProduct.error.productAlreadyExists"); return false; } } void onSave(final DataDefinition orderedProductDD, final Entity orderedProduct); void calculateOrderedProductPricePerUnit(final DataDefinition orderedProductDD, final Entity orderedProduct); boolean checkIfOrderedProductAlreadyExists(final DataDefinition orderedProductDD, final Entity orderedProduct); static final String OPERATION; static final String OFFER; }### Answer: @Ignore @Test public void shouldReturnFalseAndAddErrorForEntityWhenOrderedProductAlreadyExists() throws Exception { when(searchCriteriaBuilder.uniqueResult()).thenReturn(delivery); when(orderedProductDD.getField(PRODUCT)).thenReturn(productField); boolean result = orderedProductHooks.checkIfOrderedProductAlreadyExists(orderedProductDD, orderedProduct); Assert.assertFalse(result); Mockito.verify(orderedProduct).addError(productField, "deliveries.orderedProduct.error.productAlreadyExists"); } @Ignore @Test public void shouldReturnTrue() throws Exception { when(searchCriteriaBuilder.uniqueResult()).thenReturn(null); when(orderedProductDD.getField(PRODUCT)).thenReturn(productField); boolean result = orderedProductHooks.checkIfOrderedProductAlreadyExists(orderedProductDD, orderedProduct); Assert.assertTrue(result); }
### Question: DeliveredProductHooks { public boolean checkIfDeliveredProductAlreadyExists(final DataDefinition deliveredProductDD, final Entity deliveredProduct) { SearchCriteriaBuilder searchCriteriaBuilder = getSearchRestrictions(deliveredProductDD.find(), deliveredProduct); if (deliveredProduct.getId() != null) { searchCriteriaBuilder.add(SearchRestrictions.ne("id", deliveredProduct.getId())); } Entity deliveredProductFromDB = searchCriteriaBuilder.setMaxResults(1).uniqueResult(); if (deliveredProductFromDB == null) { return true; } else { deliveredProduct.addError(deliveredProductDD.getField(PRODUCT), "deliveries.deliveredProduct.error.productAlreadyExists"); return false; } } void onCreate(final DataDefinition deliveredProductDD, final Entity deliveredProduct); void onSave(final DataDefinition deliveredProductDD, final Entity deliveredProduct); boolean onDelete(final DataDefinition dataDefinition, final Entity deliveredProduct); void calculateDeliveredProductPricePerUnit(final DataDefinition deliveredProductDD, final Entity deliveredProduct); boolean validatesWith(final DataDefinition deliveredProductDD, final Entity deliveredProduct); boolean checkIfDeliveredProductAlreadyExists(final DataDefinition deliveredProductDD, final Entity deliveredProduct); boolean checkIfDeliveredQuantityIsLessThanDamagedQuantity(final DataDefinition deliveredProductDD, final Entity deliveredProduct); static final String OFFER; static final String OPERATION; static final String EXPIRATION_DATE; }### Answer: @Ignore @Test public void shouldReturnFalseAndAddErrorForEntityWhenDeliveredProductAlreadyExists() throws Exception { when(searchCriteriaBuilder.uniqueResult()).thenReturn(delivery); when(deliveredProductDD.getField(PRODUCT)).thenReturn(productField); boolean result = deliveredProductHooks.checkIfDeliveredProductAlreadyExists(deliveredProductDD, deliveredProduct); Assert.assertFalse(result); Mockito.verify(deliveredProduct).addError(productField, "deliveries.deliveredProduct.error.productAlreadyExists"); } @Ignore @Test public void shouldReturnTrue() throws Exception { when(searchCriteriaBuilder.uniqueResult()).thenReturn(null); when(deliveredProductDD.getField(PRODUCT)).thenReturn(productField); boolean result = deliveredProductHooks.checkIfDeliveredProductAlreadyExists(deliveredProductDD, deliveredProduct); Assert.assertTrue(result); }
### Question: DeliveryDetailsHooks { public void fillCompanyFieldsForSupplier(final ViewDefinitionState view) { LookupComponent supplierLookup = (LookupComponent) view.getComponentByReference(DeliveryFields.SUPPLIER); FieldComponent deliveryDateBufferField = (FieldComponent) view .getComponentByReference(DeliveryFields.DELIVERY_DATE_BUFFER); FieldComponent paymentFormField = (FieldComponent) view.getComponentByReference(DeliveryFields.PAYMENT_FORM); Entity supplier = supplierLookup.getEntity(); if (supplier == null) { deliveryDateBufferField.setFieldValue(null); paymentFormField.setFieldValue(null); } else { deliveryDateBufferField.setFieldValue(supplier.getIntegerField(CompanyFieldsD.BUFFER)); paymentFormField.setFieldValue(supplier.getStringField(CompanyFieldsD.PAYMENT_FORM)); } deliveryDateBufferField.requestComponentUpdateState(); paymentFormField.requestComponentUpdateState(); } void generateDeliveryNumber(final ViewDefinitionState view); void fillCompanyFieldsForSupplier(final ViewDefinitionState view); void changeFieldsEnabledDependOnState(final ViewDefinitionState view); void fillDeliveryAddressDefaultValue(final ViewDefinitionState view); void fillDescriptionDefaultValue(final ViewDefinitionState view); void filterStateChangeHistory(final ViewDefinitionState view); void updateRelatedDeliveryButtonsState(final ViewDefinitionState view); void fillCurrencyFields(final ViewDefinitionState view); void disableShowProductButton(final ViewDefinitionState view); void fillLocationDefaultValue(final ViewDefinitionState view); void changeLocationEnabledDependOnState(final ViewDefinitionState view); void updateCopyOrderedProductButtonsState(final ViewDefinitionState view); void processRoles(final ViewDefinitionState view); void onBeforeRender(final ViewDefinitionState view); void updateChangeStorageLocationButton(final ViewDefinitionState view); void setDeliveryIdForMultiUploadField(final ViewDefinitionState view); }### Answer: @Test public void shouldFillCompanyFields() throws Exception { Integer buffer = Integer.valueOf(10); String paymentForm = "cash"; when(view.getComponentByReference(SUPPLIER)).thenReturn(supplierLookup); when(view.getComponentByReference(L_DELIVERY_DATE_BUFFER)).thenReturn(deliveryDateBufferField); when(view.getComponentByReference(L_PAYMENT_FORM)).thenReturn(paymentFormField); when(supplierLookup.getEntity()).thenReturn(supplier); when(supplier.getIntegerField(CompanyFieldsD.BUFFER)).thenReturn(buffer); when(supplier.getStringField(CompanyFieldsD.PAYMENT_FORM)).thenReturn(paymentForm); deliveryDetailsHooks.fillCompanyFieldsForSupplier(view); verify(deliveryDateBufferField).setFieldValue(buffer); verify(paymentFormField).setFieldValue(paymentForm); } @Test public void shouldntFillCompanyFieldsWhenSupplierIsNotSelected() throws Exception { when(view.getComponentByReference(SUPPLIER)).thenReturn(supplierLookup); when(view.getComponentByReference(L_DELIVERY_DATE_BUFFER)).thenReturn(deliveryDateBufferField); when(view.getComponentByReference(L_PAYMENT_FORM)).thenReturn(paymentFormField); when(supplierLookup.getEntity()).thenReturn(null); deliveryDetailsHooks.fillCompanyFieldsForSupplier(view); verify(deliveryDateBufferField).setFieldValue(null); verify(paymentFormField).setFieldValue(null); }
### 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: WorkPlansColumnFiller implements ColumnFiller { @Override public Map<Entity, Map<String, String>> getValues(final List<Entity> orders) { Map<Entity, Map<String, String>> values = new HashMap<Entity, Map<String, String>>(); for (Entity order : orders) { OperationProductComponentWithQuantityContainer productQuantities = productQuantitiesService .getProductComponentQuantities(order); Entity technology = order.getBelongsToField(OrderFields.TECHNOLOGY); fillProductNames(technology, values); fillPlannedQuantities(technology, productQuantities, 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 shouldReturnCorrectColumnValuesForProducts() { EntityTree operComps = mockEntityTree(asList(operationComponent)); EntityTree operComps2 = mockEntityTree(asList(operationComponent)); given(technology.getTreeField(TechnologyFields.OPERATION_COMPONENTS)).willReturn(operComps, operComps2); given(operationComponent.getStringField(TechnologyOperationComponentFields.ENTITY_TYPE)).willReturn( TechnologyOperationComponentEntityType.OPERATION.getStringValue()); given(operationComponent.getId()).willReturn(1L); EntityList prodInComps = mockEntityList(asList(operationProductComponent)); EntityList prodInComps2 = mockEntityList(asList(operationProductComponent)); given(operationProductComponent.getBelongsToField("operationComponent")).willReturn(operationComponent); given(operationProductComponent.getBelongsToField(L_PRODUCT)).willReturn(product); given(operationComponent.getHasManyField(TechnologyOperationComponentFields.OPERATION_PRODUCT_IN_COMPONENTS)).willReturn( prodInComps, prodInComps2); EntityList prodOutComps = mockEntityList(new ArrayList<Entity>()); given(operationComponent.getHasManyField(TechnologyOperationComponentFields.OPERATION_PRODUCT_OUT_COMPONENTS)) .willReturn(prodOutComps); given(operationProductComponent.getDataDefinition()).willReturn(operationProductComponentDD); given(operationProductComponentDD.getName()).willReturn(TechnologiesConstants.MODEL_OPERATION_PRODUCT_IN_COMPONENT); OperationProductComponentWithQuantityContainer quantities = new OperationProductComponentWithQuantityContainer(); quantities.put(operationProductComponent, new BigDecimal(11)); given(productQuantitiesService.getProductComponentQuantities(order)).willReturn(quantities); Map<Entity, Map<String, String>> columnValues = workPlansColumnFiller.getValues(asList(order)); assertEquals(1, columnValues.size()); assertEquals("product (123)", columnValues.get(operationProductComponent).get(L_PRODUCT_NAME)); assertEquals("11.00000 abc", columnValues.get(operationProductComponent).get(L_PLANNED_QUANTITY)); }
### 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: WorkPlansColumnLoaderServiceImpl implements WorkPlansColumnLoaderService { public void setParameterDefaultValues() { Entity parameter = parameterService.getParameter(); for (String fieldName : Lists.newArrayList(ParameterFieldsWP.HIDE_DESCRIPTION_IN_WORK_PLANS, ParameterFieldsWP.HIDE_TECHNOLOGY_AND_ORDER_IN_WORK_PLANS, ParameterFieldsWP.IMAGE_URL_IN_WORK_PLAN, ParameterFieldsWP.DONT_PRINT_INPUT_PRODUCTS_IN_WORK_PLANS, ParameterFieldsWP.DONT_PRINT_OUTPUT_PRODUCTS_IN_WORK_PLANS)) { if (fieldName.equals(ParameterFieldsWP.IMAGE_URL_IN_WORK_PLAN)) { continue; } parameter.setField(fieldName, false); } parameter.getDataDefinition().save(parameter); if (parameter.isValid() && LOG.isDebugEnabled()) { LOG.debug("Parameter saved {parameter = " + parameter.toString() + "}"); } } 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: @Test public void shouldSetParameterDefaultValuesIfParameterIsntNull() { when(parameterService.getParameter()).thenReturn(parameter); when(parameter.isValid()).thenReturn(true); when(parameter.getDataDefinition()).thenReturn(parameterDD); when(parameterDD.save(parameter)).thenReturn(parameter); workPlansColumnLoaderServiceImpl.setParameterDefaultValues(); verify(parameter).setField(ParameterFieldsWP.HIDE_DESCRIPTION_IN_WORK_PLANS, false); verify(parameter).setField(ParameterFieldsWP.HIDE_TECHNOLOGY_AND_ORDER_IN_WORK_PLANS, false); verify(parameter).setField(ParameterFieldsWP.DONT_PRINT_INPUT_PRODUCTS_IN_WORK_PLANS, false); verify(parameter).setField(ParameterFieldsWP.DONT_PRINT_OUTPUT_PRODUCTS_IN_WORK_PLANS, false); }
### 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: DeliveriesServiceImpl implements DeliveriesService { @Override public Entity getDelivery(final Long deliveryId) { return getDeliveryDD().get(deliveryId); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnNullWhenGetDelivery() { Long deliveryId = null; given(deliveryDD.get(deliveryId)).willReturn(null); Entity result = deliveriesService.getDelivery(deliveryId); assertEquals(null, result); } @Test public void shouldReturnDeliveryWhenGetDelivery() { Long deliveryId = 1L; given(deliveryDD.get(deliveryId)).willReturn(delivery); Entity result = deliveriesService.getDelivery(deliveryId); assertEquals(delivery, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public Entity getOrderedProduct(final Long deliveredProductId) { return getOrderedProductDD().get(deliveredProductId); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnNullWhenGetOrderedProduct() { Long orderedProductId = null; given(orderedProductDD.get(orderedProductId)).willReturn(null); Entity result = deliveriesService.getOrderedProduct(orderedProductId); assertEquals(null, result); } @Test public void shouldReturnOrderedProductWhenGetOrderedProduct() { Long orderedProductId = 1L; given(orderedProductDD.get(orderedProductId)).willReturn(orderedProduct); Entity result = deliveriesService.getOrderedProduct(orderedProductId); assertEquals(orderedProduct, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public Entity getDeliveredProduct(final Long deliveredProductId) { return getDeliveredProductDD().get(deliveredProductId); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnNullWhenGetDeliveredProduct() { Long deliveredProductId = null; given(deliveredProductDD.get(deliveredProductId)).willReturn(null); Entity result = deliveriesService.getDeliveredProduct(deliveredProductId); assertEquals(null, result); } @Test public void shouldReturnDeliveredProductWhenGetDeliveredProduct() { Long deliveredProductId = 1L; given(deliveredProductDD.get(deliveredProductId)).willReturn(deliveredProduct); Entity result = deliveriesService.getDeliveredProduct(deliveredProductId); assertEquals(deliveredProduct, result); } @Test public void shouldReturnNullWhenGetCompanyProduct() { Long companyProductId = null; given(companyProductDD.get(companyProductId)).willReturn(null); Entity result = deliveriesService.getDeliveredProduct(companyProductId); assertEquals(null, result); } @Test public void shouldReturnNullWhenGetCompanyProductsFamily() { Long companyProductsFamilyId = null; given(companyProductsFamilyDD.get(companyProductsFamilyId)).willReturn(null); Entity result = deliveriesService.getDeliveredProduct(companyProductsFamilyId); assertEquals(null, result); }
### 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: DeliveriesServiceImpl implements DeliveriesService { @Override public Entity getCompanyProduct(final Long companyProductId) { return getCompanyProductDD().get(companyProductId); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnCompanyProductWhenGetCompanyProduct() { Long companyProductId = 1L; given(companyProductDD.get(companyProductId)).willReturn(companyProduct); Entity result = deliveriesService.getCompanyProduct(companyProductId); assertEquals(companyProduct, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public Entity getCompanyProductsFamily(final Long companyProductsFamilyId) { return getCompanyProductsFamilyDD().get(companyProductsFamilyId); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnCompanyProductsFamilyWhenGetCompanyProductsFamily() { Long companyProductsFamilyId = 1L; given(companyProductsFamilyDD.get(companyProductsFamilyId)).willReturn(companyProductsFamily); Entity result = deliveriesService.getCompanyProductsFamily(companyProductsFamilyId); assertEquals(companyProductsFamily, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public List<Entity> getColumnsForDeliveries() { List<Entity> columnsForDeliveries = getColumnForDeliveriesDD().find() .addOrder(SearchOrders.asc(ColumnForDeliveriesFields.SUCCESSION)).list().getEntities(); List<Entity> deliveriesColumn = new ArrayList<Entity>(); Entity successionColumn = getColumnForDeliveriesDD().find() .add(SearchRestrictions.eq(ColumnForDeliveriesFields.IDENTIFIER, "succession")).uniqueResult(); deliveriesColumn.add(successionColumn); for (Entity entity : columnsForDeliveries) { if (!entity.getStringField(ColumnForDeliveriesFields.IDENTIFIER).equals( successionColumn.getStringField(ColumnForDeliveriesFields.IDENTIFIER))) { deliveriesColumn.add(entity); } } return deliveriesColumn; } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Ignore @Test public void shouldReturnNullWhenGetColumnsForDeliveriesIfColumnsForDeliveriesAreNull() { given(columnForDeliveriesDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.addOrder(Mockito.any(SearchOrder.class))).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(null); List<Entity> result = deliveriesService.getColumnsForDeliveries(); assertEquals(null, result); } @Ignore @Test public void shouldReturnColumnsForDeliveriesWhenGetColumnsForDeliveriesIfColumnsForDeliveriesArentNull() { given(columnForDeliveriesDD.find()).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.addOrder(Mockito.any(SearchOrder.class))).willReturn(searchCriteriaBuilder); given(searchCriteriaBuilder.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(columnsForDeliveries); List<Entity> result = deliveriesService.getColumnsForDeliveries(); assertEquals(columnsForDeliveries, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getDeliveryDD() { return dataDefinitionService.get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_DELIVERY); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnDeliveryDD() { DataDefinition result = deliveriesService.getDeliveryDD(); assertEquals(deliveryDD, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getOrderedProductDD() { return dataDefinitionService.get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_ORDERED_PRODUCT); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnOrderedProductDD() { DataDefinition result = deliveriesService.getOrderedProductDD(); assertEquals(orderedProductDD, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getDeliveredProductDD() { return dataDefinitionService.get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_DELIVERED_PRODUCT); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnDeliveredProductDD() { DataDefinition result = deliveriesService.getDeliveredProductDD(); assertEquals(deliveredProductDD, result); }
### 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: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getCompanyProductDD() { return dataDefinitionService.get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COMPANY_PRODUCT); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnCompanyProductDD() { DataDefinition result = deliveriesService.getCompanyProductDD(); assertEquals(companyProductDD, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getCompanyProductsFamilyDD() { return dataDefinitionService .get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COMPANY_PRODUCTS_FAMILY); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnCompanyProductsFamilyDD() { DataDefinition result = deliveriesService.getCompanyProductsFamilyDD(); assertEquals(companyProductsFamilyDD, result); }
### Question: DeliveriesServiceImpl implements DeliveriesService { @Override public DataDefinition getColumnForDeliveriesDD() { return dataDefinitionService.get(DeliveriesConstants.PLUGIN_IDENTIFIER, DeliveriesConstants.MODEL_COLUMN_FOR_DELIVERIES); } @Override Entity getDelivery(final Long deliveryId); @Override Entity getOrderedProduct(final Long deliveredProductId); @Override Entity getDeliveredProduct(final Long deliveredProductId); @Override Entity getCompanyProduct(final Long companyProductId); @Override Entity getCompanyProductsFamily(final Long companyProductsFamilyId); @Override List<Entity> getColumnsForDeliveries(); @Override List<Entity> getColumnsForOrders(); @Override DataDefinition getDeliveryDD(); DataDefinition getProductDD(); @Override DataDefinition getOrderedProductDD(); @Override DataDefinition getDeliveredProductDD(); @Override DataDefinition getCompanyProductDD(); @Override DataDefinition getCompanyProductsFamilyDD(); @Override DataDefinition getColumnForDeliveriesDD(); @Override DataDefinition getColumnForOrdersDD(); @Override Entity getProduct(final DeliveryProduct deliveryProduct); @Override String getDescriptionDefaultValue(); @Override String getDeliveryAddressDefaultValue(); @Override String generateAddressFromCompany(final Entity company); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames); void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames); @Override void fillUnitFields(final ViewDefinitionState view, final Entity product, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillUnitFields(final ViewDefinitionState view, final String productName, final List<String> referenceNames, final List<String> additionalUnitNames); @Override void fillCurrencyFields(final ViewDefinitionState view, final List<String> referenceNames); @Override void fillCurrencyFieldsForDelivery(final ViewDefinitionState view, final List<String> referenceNames, final Entity delivery); @Override String getCurrency(final Entity delivery); @Override void recalculatePriceFromTotalPrice(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePriceFromPricePerUnit(final ViewDefinitionState view, final String quantityFieldReference); @Override void recalculatePrice(final ViewDefinitionState view, final String quantityFieldReference); @Override BigDecimal getBigDecimalFromField(final FieldComponent fieldComponent, final Locale locale); @Override void calculatePricePerUnit(final Entity entity, final String quantityFieldName); @Override List<Entity> getColumnsWithFilteredCurrencies(final List<Entity> columns); @Override void disableShowProductButton(final ViewDefinitionState view); }### Answer: @Test public void shouldReturnColumnForDeliveriesDD() { DataDefinition result = deliveriesService.getColumnForDeliveriesDD(); assertEquals(columnForDeliveriesDD, result); }
### Question: OperationalTaskValidators { public boolean onValidate(final DataDefinition operationalTaskDD, final Entity operationalTask) { boolean isValid = true; isValid = hasName(operationalTaskDD, operationalTask) && isValid; isValid = datesAreInCorrectOrder(operationalTaskDD, operationalTask) && isValid; return isValid; } boolean onValidate(final DataDefinition operationalTaskDD, final Entity operationalTask); }### Answer: @Test public final void shouldPass() { Entity operationalTask = mockOperationalTask(OTHER_TASK_TYPE, "some name", EARLIER_DATE, LATER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertTrue(isValid); } @Test public final void shouldPassIfTypeIsNotTheOtherTask() { Entity operationalTask = mockOperationalTask(YET_ANOTHER_TASK_TYPE, null, EARLIER_DATE, LATER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertTrue(isValid); } @Test public final void shouldPassIfDatesAreTheSame() { Entity operationalTask = mockOperationalTask(OTHER_TASK_TYPE, "some name", EARLIER_DATE, EARLIER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertTrue(isValid); } @Test public final void shouldFailBecauseOfMissingName() { Entity operationalTask = mockOperationalTask(OTHER_TASK_TYPE, null, EARLIER_DATE, LATER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertFalse(isValid); } @Test public final void shouldFailBecauseOfBlankName() { Entity operationalTask = mockOperationalTask(OTHER_TASK_TYPE, " ", EARLIER_DATE, LATER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertFalse(isValid); } @Test public final void shouldFailBecauseOfWrongOrderDates() { Entity operationalTask = mockOperationalTask(OTHER_TASK_TYPE, "some name", LATER_DATE, EARLIER_DATE); boolean isValid = operationalTaskValidators.onValidate(operationalTaskDD, operationalTask); assertFalse(isValid); }
### 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: OrderMaterialCostsEntityBuilderImpl implements OrderMaterialCostsEntityBuilder { @Override public Entity create(final Entity order, final ProductWithCosts productWithCosts) { Entity orderMaterialCosts = dataDefinitionService.get(CostNormsForMaterialsConstants.PLUGIN_IDENTIFIER, CostNormsForMaterialsConstants.MODEL_TECHNOLOGY_INST_OPER_PRODUCT_IN_COMP).create(); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.ORDER, order); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.PRODUCT, productWithCosts.getProductId()); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.COST_FOR_NUMBER, productWithCosts.getCostForNumber()); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.NOMINAL_COST, productWithCosts.getNominalCost()); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.LAST_PURCHASE_COST, productWithCosts.getLastPurchaseCost()); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.AVERAGE_COST, productWithCosts.getAverageCost()); return orderMaterialCosts; } @Override Entity create(final Entity order, final ProductWithCosts productWithCosts); @Override Entity create(Entity order, Entity product); }### Answer: @Test public final void shouldBuildEntity() { Entity order = mockEntity(); ProductWithCosts productWithCosts = new ProductWithCosts(1L, BigDecimal.valueOf(2L), BigDecimal.valueOf(3L), BigDecimal.valueOf(4L), BigDecimal.valueOf(5L)); orderMaterialCostsEntityBuilder.create(order, productWithCosts); verify(createdEntity).setField(TechnologyInstOperProductInCompFields.ORDER, order); verify(createdEntity).setField(TechnologyInstOperProductInCompFields.PRODUCT, productWithCosts.getProductId()); verify(createdEntity) .setField(TechnologyInstOperProductInCompFields.COST_FOR_NUMBER, productWithCosts.getCostForNumber()); verify(createdEntity).setField(TechnologyInstOperProductInCompFields.NOMINAL_COST, productWithCosts.getNominalCost()); verify(createdEntity).setField(TechnologyInstOperProductInCompFields.LAST_PURCHASE_COST, productWithCosts.getLastPurchaseCost()); verify(createdEntity).setField(TechnologyInstOperProductInCompFields.AVERAGE_COST, productWithCosts.getAverageCost()); }
### Question: ColumnExtensionServiceImpl implements ColumnExtensionService { public Entity addColumn(final String pluginIdentifier, final String model, final Map<String, String> columnAttributes) { Entity column = getColumnDD(pluginIdentifier, model).create(); column.setField(IDENTIFIER, columnAttributes.get(IDENTIFIER.toLowerCase(Locale.ENGLISH))); column.setField(NAME, columnAttributes.get(NAME.toLowerCase(Locale.ENGLISH))); column.setField(DESCRIPTION, columnAttributes.get(DESCRIPTION.toLowerCase(Locale.ENGLISH))); column.setField(COLUMN_FILLER, columnAttributes.get(COLUMN_FILLER.toLowerCase(Locale.ENGLISH))); column.setField(ALIGNMENT, columnAttributes.get(ALIGNMENT.toLowerCase(Locale.ENGLISH))); if (LOG.isDebugEnabled()) { LOG.debug("Add column for " + model + " item {column=" + column.getStringField(NAME) + "}"); } column = column.getDataDefinition().save(column); if (column.isValid()) { if (LOG.isDebugEnabled()) { LOG.debug("Column for " + model + " saved {column=" + column.toString() + "}"); } return column; } else { throw new IllegalStateException("Saved entity " + model + " has validation errors - " + columnAttributes.get(IDENTIFIER.toLowerCase(Locale.ENGLISH))); } } 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 shouldAddColumn() { String pluginIdentifier = "plugin"; String model = "model"; given(dataDefinitionService.get(pluginIdentifier, model)).willReturn(entityDD); given(entityDD.create()).willReturn(entity); given(entity.getDataDefinition()).willReturn(entityDD); given(entityDD.save(entity)).willReturn(entity); given(entity.isValid()).willReturn(true); Entity result = columnExtensionService.addColumn(pluginIdentifier, model, columnAttributes); Assert.assertSame(entity, result); }
### 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: QualityControlService { public void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state) { FieldComponent comment = (FieldComponent) state.getComponentByReference(FIELD_COMMENT); FieldComponent controlResult = (FieldComponent) state.getComponentByReference(FIELD_CONTROL_RESULT); if (controlResult != null && controlResult.getFieldValue() != null && "03objection".equals(controlResult.getFieldValue())) { comment.setRequired(true); comment.requestComponentUpdateState(); } else { comment.setRequired(false); } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetRequiredOnCommentForControlResult() { FormComponent form = mock(FormComponent.class); FieldComponent comment = mock(FieldComponent.class); FieldComponent controlResult = mock(FieldComponent.class); ViewDefinitionState state = mock(ViewDefinitionState.class); given(state.getComponentByReference("comment")).willReturn(comment); given(state.getComponentByReference("controlResult")).willReturn(controlResult); given(state.getComponentByReference("controlResult").getFieldValue()).willReturn("03objection"); given(state.getComponentByReference("form")).willReturn(form); qualityControlService.checkIfCommentIsRequiredBasedOnResult(state); verify(comment).setRequired(true); verify(state, atLeastOnce()).getComponentByReference(anyString()); verifyNoMoreInteractions(state); }
### Question: QualityControlService { public void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state) { FieldComponent comment = (FieldComponent) state.getComponentByReference(FIELD_COMMENT); FieldComponent acceptedDefectsQuantity = (FieldComponent) state .getComponentByReference(ACCEPTED_DEFECTS_QUANTITY_LITERAL); if (acceptedDefectsQuantity.getFieldValue() != null && !acceptedDefectsQuantity.getFieldValue().toString().isEmpty() && (new BigDecimal(acceptedDefectsQuantity.getFieldValue().toString().replace(",", ".")) .compareTo(BigDecimal.ZERO) > 0)) { comment.setRequired(true); comment.requestComponentUpdateState(); } else { comment.setRequired(false); } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetRequiredOnCommentForDefects() { FormComponent form = mock(FormComponent.class); FieldComponent comment = mock(FieldComponent.class); FieldComponent acceptedDefectsQuantity = mock(FieldComponent.class); ViewDefinitionState state = mock(ViewDefinitionState.class); given(state.getComponentByReference("comment")).willReturn(comment); given(state.getComponentByReference("acceptedDefectsQuantity")).willReturn(acceptedDefectsQuantity); given(state.getComponentByReference("acceptedDefectsQuantity").getFieldValue()).willReturn(new BigDecimal("12")); given(state.getComponentByReference("form")).willReturn(form); qualityControlService.checkIfCommentIsRequiredBasedOnDefects(state); verify(comment).setRequired(true); verify(state, atLeastOnce()).getComponentByReference(anyString()); verifyNoMoreInteractions(state); }
### Question: QualityControlService { public void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args) { if (!(state instanceof FieldComponent)) { throw new IllegalStateException("component is not select"); } FieldComponent resultType = (FieldComponent) state; FieldComponent comment = (FieldComponent) viewDefinitionState.getComponentByReference(FIELD_COMMENT); if (resultType.getFieldValue() != null && "03objection".equals(resultType.getFieldValue())) { comment.setRequired(true); } else { comment.setRequired(false); } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetRequiredOnCommentAfterSelectChange() { FieldComponent resultType = mock(FieldComponent.class); FieldComponent comment = mock(FieldComponent.class); ViewDefinitionState state = mock(ViewDefinitionState.class); given(resultType.getFieldValue()).willReturn("03objection"); given(state.getComponentByReference("comment")).willReturn(comment); qualityControlService.checkQualityControlResult(state, resultType, new String[] {}); verify(comment).setRequired(true); }
### Question: QualityControlService { public boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity) { String qualityControlType = entity.getStringField(QUALITY_CONTROL_TYPE_LITERAL); if (hasControlResult(qualityControlType)) { return checkIfCommentForResultIsReq(dataDefinition, entity); } else { return checkIfCommentForQuantityIsReq(dataDefinition, entity); } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetErrorOnCommentFieldForResultType() { Entity entity = mock(Entity.class); DataDefinition dataDefinition = mock(DataDefinition.class); given(entity.getStringField("qualityControlType")).willReturn("qualityControlsForOrder"); given(entity.getStringField("controlResult")).willReturn("03objection"); given(entity.getField("comment")).willReturn(null); qualityControlService.checkIfCommentForResultOrQuantityIsReq(dataDefinition, entity); verify(entity).addGlobalError("smartView.validate.global.error.custom"); verify(entity).addError(dataDefinition.getField("comment"), "qualityControls.quality.control.validate.global.error.comment"); } @Test public void shouldSetErrorOnCommentFieldForAcceptedDefectsQuantity() { Entity entity = mock(Entity.class); DataDefinition dataDefinition = mock(DataDefinition.class); given(entity.getStringField("qualityControlType")).willReturn("qualityControlsForUnit"); given(entity.getDecimalField("acceptedDefectsQuantity")).willReturn(new BigDecimal("1")); given(entity.getField("comment")).willReturn(null); qualityControlService.checkIfCommentForResultOrQuantityIsReq(dataDefinition, entity); verify(entity).addGlobalError("smartView.validate.global.error.custom"); verify(entity).addError(dataDefinition.getField("comment"), "qualityControls.quality.control.validate.global.error.comment"); }
### Question: QualityControlService { public void enableCalendarsOnRender(final ViewDefinitionState state) { FieldComponent dateFrom = (FieldComponent) state.getComponentByReference(DATE_FROM_LITERAL); FieldComponent dateTo = (FieldComponent) state.getComponentByReference(DATE_TO_LITERAL); dateFrom.setEnabled(true); dateTo.setEnabled(true); } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldEnableCalendarsOnPreRender() { FieldComponent dateFrom = mock(FieldComponent.class); FieldComponent dateTo = mock(FieldComponent.class); ViewDefinitionState state = mock(ViewDefinitionState.class); given(state.getComponentByReference("dateFrom")).willReturn(dateFrom); given(state.getComponentByReference("dateTo")).willReturn(dateTo); qualityControlService.enableCalendarsOnRender(state); verify(dateFrom).setEnabled(true); verify(dateTo).setEnabled(true); }
### Question: QualityControlService { public void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args) { if (!(state instanceof FieldComponent)) { throw new IllegalStateException("component is not input"); } FieldComponent acceptedDefectsQuantity = (FieldComponent) state; FieldComponent comment = (FieldComponent) viewDefinitionState.getComponentByReference(FIELD_COMMENT); if (acceptedDefectsQuantity.getFieldValue() != null) { if (isNumber(acceptedDefectsQuantity.getFieldValue().toString()) && (new BigDecimal(acceptedDefectsQuantity.getFieldValue().toString())).compareTo(BigDecimal.ZERO) > 0) { comment.setRequired(true); } else { comment.setRequired(false); } } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetCommentAsRequiredOnPositiveDefectsQuantity() { ViewDefinitionState viewDefinitionState = mock(ViewDefinitionState.class); FieldComponent acceptedDefectsQuantity = mock(FieldComponent.class); FieldComponent comment = mock(FieldComponent.class); given(viewDefinitionState.getComponentByReference("comment")).willReturn(comment); given(acceptedDefectsQuantity.getFieldValue()).willReturn("1"); given(acceptedDefectsQuantity.getFieldValue().toString()).willReturn("1"); qualityControlService.checkAcceptedDefectsQuantity(viewDefinitionState, acceptedDefectsQuantity, new String[] {}); verify(comment).setRequired(true); } @Test public void shouldSetCommentAsNotRequiredOnPositiveDefectsQuantity() { ViewDefinitionState viewDefinitionState = mock(ViewDefinitionState.class); FieldComponent state = mock(FieldComponent.class); FieldComponent comment = mock(FieldComponent.class); given(viewDefinitionState.getComponentByReference("comment")).willReturn(comment); given(state.getFieldValue()).willReturn("0"); given(state.getFieldValue().toString()).willReturn("0"); qualityControlService.checkAcceptedDefectsQuantity(viewDefinitionState, state, new String[] {}); verify(comment).setRequired(false); }
### Question: QualityControlService { public void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args) { if (!(state instanceof FieldComponent)) { return; } FieldComponent order = (FieldComponent) state; FieldComponent controlInstruction = (FieldComponent) viewDefinitionState .getComponentByReference(CONTROL_INSTRUCTION_LITERAL); if (controlInstruction == null) { return; } else { controlInstruction.setFieldValue(""); } if (order.getFieldValue() != null) { String qualityControlInstruction = getInstructionForOrder((Long) order.getFieldValue()); if (qualityControlInstruction != null) { controlInstruction.setFieldValue(qualityControlInstruction); } } } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetQualityControlInstructionToDefaultFromTechnology() { ViewDefinitionState viewDefinitionState = mock(ViewDefinitionState.class); FieldComponent state = mock(FieldComponent.class); FieldComponent controlInstruction = mock(FieldComponent.class); DataDefinition orderDD = mock(DataDefinition.class); SearchCriteriaBuilder searchCriteria = mock(SearchCriteriaBuilder.class); Entity technology = mock(Entity.class); given(technology.getField("qualityControlInstruction")).willReturn("test"); given(technology.getStringField("qualityControlInstruction")).willReturn("test"); List<Entity> orders = new ArrayList<Entity>(); Entity genealogy = mock(Entity.class); given(genealogy.getBelongsToField("technology")).willReturn(technology); orders.add(genealogy); given(viewDefinitionState.getComponentByReference("controlInstruction")).willReturn(controlInstruction); given(state.getFieldValue()).willReturn(1L); given(dataDefinitionService.get("orders", "order")).willReturn(orderDD); given(orderDD.find()).willReturn(searchCriteria); given(searchCriteria.setMaxResults(anyInt())).willReturn(searchCriteria); given(searchCriteria.add(any(SearchCriterion.class))).willReturn(searchCriteria); SearchResult searchResult = mock(SearchResult.class); given(searchCriteria.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(orders); qualityControlService.setQualityControlInstruction(viewDefinitionState, state, new String[] {}); verify(controlInstruction).setFieldValue(""); verify(controlInstruction).setFieldValue("test"); }
### Question: QualityControlService { public void setOperationAsRequired(final ViewDefinitionState state) { FieldComponent operation = (FieldComponent) state.getComponentByReference(OPERATION_LITERAL); operation.setRequired(true); } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetOperationAsRequired() { ViewDefinitionState viewDefinitionState = mock(ViewDefinitionState.class); FieldComponent operation = mock(FieldComponent.class); given(viewDefinitionState.getComponentByReference("operation")).willReturn(operation); qualityControlService.setOperationAsRequired(viewDefinitionState); verify(operation).setRequired(true); }
### Question: QualityControlService { public void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState) { FormComponent qualityControlsForm = (FormComponent) viewDefinitionState.getComponentByReference(FORM_LITERAL); String qualityControlTypeString = qualityControlsForm.getName().replace("Control", "Controls"); FieldComponent qualityControlType = (FieldComponent) viewDefinitionState .getComponentByReference(QUALITY_CONTROL_TYPE_LITERAL); qualityControlType.setFieldValue(qualityControlTypeString); } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetQualityControlTypeHiddenFieldToQualityControlsForBatch() { ViewDefinitionState viewDefinitionState = mock(ViewDefinitionState.class); FormComponent qualityControlsForm = mock(FormComponent.class); FieldComponent qualityControlType = mock(FieldComponent.class); FieldComponent closed = mock(FieldComponent.class); given(viewDefinitionState.getComponentByReference("form")).willReturn(qualityControlsForm); given(qualityControlsForm.getName()).willReturn("qualityControlForBatch"); given(viewDefinitionState.getComponentByReference("qualityControlType")).willReturn(qualityControlType); given(viewDefinitionState.getComponentByReference("closed")).willReturn(closed); qualityControlService.setQualityControlTypeHiddenField(viewDefinitionState); verify(qualityControlType).setFieldValue("qualityControlsForBatch"); }
### Question: QualityControlService { public boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity) { String qualityControlType = entity.getStringField(QUALITY_CONTROL_TYPE_LITERAL); if (QUALITY_CONTROLS_FOR_OPERATION_LITERAL.equals(qualityControlType)) { Object operation = entity.getField(OPERATION_LITERAL); if (operation == null) { entity.addGlobalError(QCADOO_VIEW_VALIDATE_GLOBAL_ERROR_CUSTOM); entity.addError(dataDefinition.getField(OPERATION_LITERAL), "qualityControls.quality.control.validate.global.error.operation"); return false; } } return true; } void setTechnology(final ViewDefinitionState view); void checkIfCommentIsRequiredBasedOnResult(final ViewDefinitionState state); void setQualityControlTypeForTechnology(final DataDefinition dataDefinition, final Entity entity); void checkIfCommentIsRequiredBasedOnDefects(final ViewDefinitionState state); boolean checkIfCommentForResultOrQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForResultIsReq(final DataDefinition dataDefinition, final Entity entity); boolean checkIfCommentForQuantityIsReq(final DataDefinition dataDefinition, final Entity entity); void checkQualityControlResult(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void closeQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void autoGenerateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void generateQualityControl(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void checkAcceptedDefectsQuantity(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void setQualityControlInstruction(final ViewDefinitionState viewDefinitionState, final ComponentState state, final String[] args); void enableCalendarsOnRender(final ViewDefinitionState state); void setQuantitiesToDefaulIfEmpty(final ViewDefinitionState state); void addRestrictionToQualityControlGrid(final ViewDefinitionState viewDefinitionState); void setQualityControlTypeHiddenField(final ViewDefinitionState viewDefinitionState); void setOperationAsRequired(final ViewDefinitionState state); boolean checkIfOperationIsRequired(final DataDefinition dataDefinition, final Entity entity); boolean checkIfQuantitiesAreCorrect(final DataDefinition dataDefinition, final Entity entity); void disableFormForClosedControl(final ViewDefinitionState state); boolean clearQualityControlOnCopy(final DataDefinition dataDefinition, final Entity entity); boolean setStaffAndDateIfClosed(final DataDefinition dataDefinition, final Entity entity); void changeQualityControlType(final ViewDefinitionState state); }### Answer: @Test public void shouldSetErrorMessageOnEmptyOperationField() { DataDefinition qualityControlDD = mock(DataDefinition.class); FieldDefinition operation = mock(FieldDefinition.class); Entity qualityControl = mock(Entity.class); given(qualityControl.getStringField("qualityControlType")).willReturn("qualityControlsForOperation"); given(qualityControl.getBelongsToField("operation")).willReturn(null); given(qualityControlDD.getField("operation")).willReturn(operation); qualityControlService.checkIfOperationIsRequired(qualityControlDD, qualityControl); verify(qualityControl).addGlobalError("smartView.validate.global.error.custom"); verify(qualityControl).addError(qualityControlDD.getField("operation"), "qualityControls.quality.control.validate.global.error.operation"); }
### 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 disableProductFormForExternalItems(final ViewDefinitionState state) { FormComponent productForm = (FormComponent) state.getComponentByReference(L_FORM); FieldComponent entityTypeField = (FieldComponent) state.getComponentByReference(ProductFields.ENTITY_TYPE); FieldComponent parentField = (FieldComponent) state.getComponentByReference(ProductFields.PARENT); LookupComponent assortmentLookup = (LookupComponent) state.getComponentByReference(ProductFields.ASSORTMENT); Long productId = productForm.getEntityId(); if (productId == null) { productForm.setFormEnabled(true); return; } Entity product = dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT).get(productId); if (product == null) { return; } String externalNumber = product.getStringField(ProductFields.EXTERNAL_NUMBER); if (StringUtils.isEmpty(externalNumber)) { productForm.setFormEnabled(true); } else { productForm.setFormEnabled(false); entityTypeField.setEnabled(true); parentField.setEnabled(true); assortmentLookup.setEnabled(true); } } 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 shouldDisabledFormWhenExternalNumberIsNotNull() throws Exception { Long productId = 1L; given(view.getComponentByReference(L_FORM)).willReturn(productForm); given(view.getComponentByReference(ProductFields.PARENT)).willReturn(parentField); given(view.getComponentByReference(ProductFields.ENTITY_TYPE)).willReturn(entityTypeField); given(view.getComponentByReference(ProductFields.ASSORTMENT)).willReturn(assortmentLookup); given(productForm.getEntityId()).willReturn(L_ID); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT)).willReturn(productDD); given(productDD.get(productId)).willReturn(product); given(product.getStringField(ProductFields.EXTERNAL_NUMBER)).willReturn(L_EXTERNAL_NUMBER); productDetailsHooks.disableProductFormForExternalItems(view); verify(productForm).setFormEnabled(false); verify(entityTypeField).setEnabled(true); verify(parentField).setEnabled(true); } @Test public void shouldntDisabledFormWhenExternalNumberIsNull() throws Exception { Long productId = 1L; given(view.getComponentByReference(L_FORM)).willReturn(productForm); given(view.getComponentByReference(ProductFields.PARENT)).willReturn(parentField); given(view.getComponentByReference(ProductFields.ENTITY_TYPE)).willReturn(entityTypeField); given(productForm.getEntityId()).willReturn(L_ID); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT)).willReturn(productDD); given(productDD.get(productId)).willReturn(product); given(product.getStringField(ProductFields.EXTERNAL_NUMBER)).willReturn(null); productDetailsHooks.disableProductFormForExternalItems(view); verify(productForm).setFormEnabled(true); }
### 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 clearFamilyFromProductWhenTypeIsChanged(final DataDefinition productDD, final Entity product) { if (product.getId() == null) { return; } String entityType = product.getStringField(ENTITY_TYPE); Entity productFromDB = product.getDataDefinition().get(product.getId()); if (entityType.equals(PARTICULAR_PRODUCT.getStringValue()) && !entityType.equals(productFromDB.getStringField(ENTITY_TYPE))) { deleteProductFamily(productFromDB); } } 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 shouldReturnWhenEntityIdIsNull() throws Exception { when(entity.getId()).thenReturn(null); productHooks.clearFamilyFromProductWhenTypeIsChanged(dataDefinition, entity); } @Test public void shouldReturnWhenSavingEntityIsFamily() throws Exception { Long entityId = 1L; when(entity.getId()).thenReturn(entityId); when(entity.getStringField(ProductFields.ENTITY_TYPE)).thenReturn("02productsFamily"); when(entity.getDataDefinition()).thenReturn(dataDefinition); when(dataDefinition.get(entityId)).thenReturn(product); productHooks.clearFamilyFromProductWhenTypeIsChanged(dataDefinition, entity); } @Test public void shouldDeleteFamilyFromProductsWhenEntityTypeIsChanged() throws Exception { Long entityId = 1L; when(entity.getId()).thenReturn(entityId); when(entity.getStringField(ProductFields.ENTITY_TYPE)).thenReturn("01particularProduct"); when(dataDefinition.get(entityId)).thenReturn(product); when(product.getStringField(ProductFields.ENTITY_TYPE)).thenReturn("02productsFamily"); searchProductLikeParent(product); EntityList products = mockEntityListIterator(asList(prod1, prod2)); when(searchCriteria.list()).thenReturn(result); when(result.getEntities()).thenReturn(products); productHooks.clearFamilyFromProductWhenTypeIsChanged(dataDefinition, entity); Assert.assertEquals(null, prod1.getBelongsToField("parent")); Assert.assertEquals(null, prod2.getBelongsToField("parent")); }
### 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: ExchangeRatesNbpServiceImpl implements ExchangeRatesNbpService { @Override public Map<String, BigDecimal> parse(InputStream inputStream, NbpProperties nbpProperties) { Map<String, BigDecimal> exRates = new HashMap<>(); try { XMLInputFactory inputFactory = XMLInputFactory.newInstance(); XMLStreamReader sr = inputFactory.createXMLStreamReader(inputStream); sr.nextTag(); sr.nextTag(); String currencyCode = ""; BigDecimal exRate = null; BigDecimal factor = BigDecimal.ONE; String exchangeRateField = nbpProperties.fieldName(); while (sr.hasNext()) { if (sr.getEventType() == XMLStreamConstants.END_DOCUMENT) { sr.close(); } if (sr.isStartElement()) { String s = sr.getLocalName(); if (s.equals("przelicznik")) { factor = new BigDecimal(sr.getElementText().replace(',', '.')); } else if (s.equals("kod_waluty")) { currencyCode = sr.getElementText(); } else if (s.equals(exchangeRateField)) { exRate = new BigDecimal(sr.getElementText().replace(',', '.')); } if (exRate != null) { exRates.put(currencyCode, exRate.divide(factor, RoundingMode.HALF_UP)); exRate = null; } } sr.next(); } } catch (XMLStreamException e) { throw new RuntimeException(e); } finally { closeStream(inputStream); } return exRates; } @Override Map<String, BigDecimal> get(NbpProperties nbpProperties); @Override Map<String, BigDecimal> parse(InputStream inputStream, NbpProperties nbpProperties); }### Answer: @Test public void shouldParseCorrectlyGivenExampleDocument() throws Exception { Map<String, BigDecimal> map = service.parse(inputStream, ExchangeRatesNbpService.NbpProperties.LAST_C); assertTrue(map.containsKey("USD")); assertTrue(map.containsKey("CAD")); assertTrue(map.containsKey("AUD")); assertTrue(map.containsValue(new BigDecimal("0.3076"))); assertTrue(map.containsValue(new BigDecimal("2.8927"))); assertTrue(map.containsValue(new BigDecimal("2.8732"))); } @Test public void shouldParseAlwaysCloseInputStream() throws Exception { InputStream inputStreamSpied = spy(inputStream); service.parse(inputStreamSpied, ExchangeRatesNbpService.NbpProperties.LAST_C); verify(inputStreamSpied, atLeastOnce()).close(); }
### Question: ProductValidators { public boolean checkEanUniqueness(final DataDefinition productDD, final FieldDefinition eanFieldDefinition, final Entity product, final Object eanOldValue, final Object eanNewValue) { String ean = (String) eanNewValue; if (StringUtils.isEmpty(ean) \|\| ObjectUtils.equals(eanOldValue, ean)) { return true; } if (productWithEanAlreadyExists(productDD, ean)) { product.addError(eanFieldDefinition, "smartView.validate.field.error.duplicated"); return false; } return true; } boolean checkEanUniqueness(final DataDefinition productDD, final FieldDefinition eanFieldDefinition, final Entity product, final Object eanOldValue, final Object eanNewValue); }### Answer: @Test public final void shouldCheckEanUniquenessJustReturnTrueIfNewEanIsEmpty() { String oldVal = "123456"; String newVal = ""; boolean isValid = productValidators.checkEanUniqueness(dataDefinition, fieldDefinition, entity, oldVal, newVal); assertTrue(isValid); verify(entity, never()).addError(any(FieldDefinition.class), anyString()); } @Test public final void shouldCheckEanUniquenessJustReturnTrueIfNewEanIsNull() { String oldVal = "123456"; String newVal = null; boolean isValid = productValidators.checkEanUniqueness(dataDefinition, fieldDefinition, entity, oldVal, newVal); assertTrue(isValid); verify(entity, never()).addError(any(FieldDefinition.class), anyString()); } @Test public final void shouldCheckEanUniquenessReturnTrueIfThereIsNoExistingProductsWithGivenId() { String oldVal = "123456"; String newVal = "654321"; ArgumentCaptor<SearchCriterion> criterionCaptor = ArgumentCaptor.forClass(SearchCriterion.class); stubSearchCriteriaWith(null); boolean isValid = productValidators.checkEanUniqueness(dataDefinition, fieldDefinition, entity, oldVal, newVal); assertTrue(isValid); verify(entity, never()).addError(any(FieldDefinition.class), anyString()); verify(scb).add(criterionCaptor.capture()); assertEquals(SearchRestrictions.eq(ProductFields.EAN, newVal), criterionCaptor.getValue()); } @Test public final void shouldCheckEanUniquenessReturnFalsAndMarkFieldAsInvalidIfProductsWithGivenIdExists() { String oldVal = "123456"; String newVal = "654321"; ArgumentCaptor<SearchCriterion> criterionCaptor = ArgumentCaptor.forClass(SearchCriterion.class); Entity resultEntity = mock(Entity.class); stubSearchCriteriaWith(resultEntity); boolean isValid = productValidators.checkEanUniqueness(dataDefinition, fieldDefinition, entity, oldVal, newVal); assertFalse(isValid); verify(entity).addError(fieldDefinition, "smartView.validate.field.error.duplicated"); verify(scb).add(criterionCaptor.capture()); assertEquals(SearchRestrictions.eq(ProductFields.EAN, newVal), criterionCaptor.getValue()); }
### 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: Shift { public Optional<DateRange> findWorkTimeAt(final Date date) { if (timetableExceptions.hasFreeTimeAt(date)) { return Optional.absent(); } DateTime dateTime = new DateTime(date); Optional<TimeRange> maybeTimeRangeFromPlan = findWorkTimeAt(dateTime.getDayOfWeek(), dateTime.toLocalTime()); for (TimeRange timeRangeFromPlan : maybeTimeRangeFromPlan.asSet()) { return Optional.of(buildDateRangeFrom(timeRangeFromPlan, date)); } return timetableExceptions.findDateRangeFor(TimetableExceptionType.WORK_TIME, date); } Shift(final Entity shiftEntity); Shift(final Entity shiftEntity, final DateTime day); Shift(final Entity shiftEntity, final DateTime day, final boolean checkWorking); boolean worksAt(final int dayOfWeek, final LocalTime time); boolean worksAt(final int dayOfWeek); boolean worksAt(final LocalDate localDate); boolean worksAt(final DateTime dateTime); @Deprecated boolean worksAt(final Date date); Optional<DateRange> findWorkTimeAt(final Date date); Optional<TimeRange> findWorkTimeAt(final int dayOfWeek, final LocalTime time); Optional<TimeRange> findWorkTimeAt(final int dayOfWeek); List<TimeRange> findWorkTimeAt(final LocalDate localDate); Entity getEntity(); Long getId(); DateTime getShiftStartDate(); void setShiftStartDate(DateTime shiftStartDate); DateTime getShiftEndDate(); void setShiftEndDate(DateTime shiftEndDate); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer: @Test public final void shouldReturnWorkingHoursForDay() { String hours = "6:00-12:00, 21:30-2:30"; given(shiftEntity.getStringField(ShiftFields.MONDAY_HOURS)).willReturn(hours); given(shiftEntity.getBooleanField(ShiftFields.MONDAY_WORKING)).willReturn(true); LocalDate mondayDate = new LocalDate(2013, 9, 2); Shift shift = new Shift(shiftEntity); List<TimeRange> timeRanges = shift.findWorkTimeAt(mondayDate); List<TimeRange> expectedTimeRanges = ImmutableList.of(new TimeRange(new LocalTime(6, 0), new LocalTime(12, 0)), new TimeRange(new LocalTime(21, 30), new LocalTime(2, 30))); assertEquals(expectedTimeRanges, timeRanges); }
### 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 boolean checkIfProductIsNotRemoved(final DataDefinition substituteDD, final Entity substitute) { Entity product = substitute.getBelongsToField(SubstituteFields.PRODUCT); if (product == null \|\| product.getId() == null) { return true; } Entity productEntity = dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT).get( product.getId()); if (productEntity == null) { substitute.addGlobalError("smartView.message.belongsToNotFound"); substitute.setField(SubstituteFields.PRODUCT, null); return false; } return true; } 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 shouldReturnTrueWhenProductIsNotRemoved() throws Exception { boolean result = productService.checkIfProductIsNotRemoved(productDD, product); assertTrue(result); } @Test public void shouldReturnFalseWhenEntityDoesnotExists() throws Exception { DataDefinition productDD = Mockito.mock(DataDefinition.class); Long productId = 1L; given(substitute.getBelongsToField(SubstituteFields.PRODUCT)).willReturn(product); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT)).willReturn(productDD); given(product.getId()).willReturn(productId); given(productDD.get(productId)).willReturn(null); boolean result = productService.checkIfProductIsNotRemoved(substituteDD, substitute); assertFalse(result); } @Test public void shouldReturnTrueWhenProductExists() throws Exception { DataDefinition productDD = Mockito.mock(DataDefinition.class); Long productId = 1L; given(substitute.getBelongsToField(SubstituteFields.PRODUCT)).willReturn(product); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT)).willReturn(productDD); given(product.getId()).willReturn(productId); given(productDD.get(productId)).willReturn(product); boolean result = productService.checkIfProductIsNotRemoved(substituteDD, substitute); assertTrue(result); }
### Question: ProductService { public boolean checkIfSubstituteIsNotRemoved(final DataDefinition substituteComponentDD, final Entity substituteComponent) { Entity substitute = substituteComponent.getBelongsToField(SubstituteComponentFields.SUBSTITUTE); if (substitute == null \|\| substitute.getId() == null) { return true; } Entity substituteEntity = dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_SUBSTITUTE) .get(substitute.getId()); if (substituteEntity == null) { substituteComponent.addGlobalError("smartView.message.belongsToNotFound"); substituteComponent.setField(SubstituteComponentFields.SUBSTITUTE, null); return false; } else { return true; } } 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 shouldReturnFalseWhenSubstituteDoesnotExists() throws Exception { DataDefinition substituteDD = Mockito.mock(DataDefinition.class); Long substituteId = 1L; given(substituteComponent.getBelongsToField(SubstituteComponentFields.SUBSTITUTE)).willReturn(substitute); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_SUBSTITUTE)).willReturn( substituteDD); given(substitute.getId()).willReturn(substituteId); given(substituteDD.get(substituteId)).willReturn(null); boolean result = productService.checkIfSubstituteIsNotRemoved(substituteComponentDD, substituteComponent); assertFalse(result); } @Test public void shouldReturnTrueWhenEntityDoesnotHaveBTSubstitute() throws Exception { boolean result = productService.checkIfSubstituteIsNotRemoved(substituteComponentDD, substituteComponent); assertTrue(result); } @Test public void shouldReturnTrueWhenSubstitueExists() throws Exception { DataDefinition substituteDD = Mockito.mock(DataDefinition.class); Long substituteId = 1L; given(substituteComponent.getBelongsToField(SubstituteComponentFields.SUBSTITUTE)).willReturn(substitute); given(dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_SUBSTITUTE)).willReturn( substituteDD); given(substitute.getId()).willReturn(substituteId); given(substituteDD.get(substituteId)).willReturn(substitute); boolean result = productService.checkIfSubstituteIsNotRemoved(substituteComponentDD, substituteComponent); assertTrue(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: TechnologyOperationComponentHooksOTFO { public void changeDescriptionInOperationalTasksWhenChanged(final DataDefinition technologyOperationComponentDD, final Entity technologyOperationComponent) { Long technologyOperationComponentId = technologyOperationComponent.getId(); if (technologyOperationComponentId == null) { return; } Entity technologyOperationComponentFromDB = technologyOperationComponentDD.get(technologyOperationComponentId); String comment = (technologyOperationComponent.getStringField(TechnologyOperationComponentFields.COMMENT) == null) ? "" : technologyOperationComponent.getStringField(TechnologyOperationComponentFields.COMMENT); String technologyOperationComponentComment = (technologyOperationComponentFromDB .getStringField(TechnologyOperationComponentFields.COMMENT) == null) ? "" : technologyOperationComponentFromDB .getStringField(TechnologyOperationComponentFields.COMMENT); if (!comment.equals(technologyOperationComponentComment)) { changedDescriptionInOperationalTasks(technologyOperationComponent); } } void changeDescriptionInOperationalTasksWhenChanged(final DataDefinition technologyOperationComponentDD, final Entity technologyOperationComponent); }### Answer: @Test public void shouldReturnWhenEntityIdIsNull() throws Exception { Long technologyOperationComponentId = null; String comment = "comment"; given(technologyOperationComponent.getId()).willReturn(technologyOperationComponentId); technologyOperationComponentHooksOTFO.changeDescriptionInOperationalTasksWhenChanged(technologyOperationComponentDD, technologyOperationComponent); Mockito.verify(operationalTask, Mockito.never()).setField(OperationalTaskFields.DESCRIPTION, comment); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Test public void shouldReturnWhenTechnologyOperationComponentCommentIsTheSame() throws Exception { Long technologyOperationComponentId = 1L; String comment = "comment"; String technologyOperationComponentComment = "comment"; given(technologyOperationComponent.getId()).willReturn(technologyOperationComponentId); given(technologyOperationComponentDD.get(technologyOperationComponentId)).willReturn(technologyOperationComponentFromDB); given(technologyOperationComponent.getStringField(TechnologyOperationComponentFields.COMMENT)).willReturn(comment); given(technologyOperationComponentFromDB.getStringField(TechnologyOperationComponentFields.COMMENT)).willReturn( technologyOperationComponentComment); technologyOperationComponentHooksOTFO.changeDescriptionInOperationalTasksWhenChanged(technologyOperationComponentDD, technologyOperationComponent); Mockito.verify(operationalTask, Mockito.never()).setField(OperationalTaskFields.DESCRIPTION, comment); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Ignore @Test public void shouldChangeOperationalTasksDescriptionWhenTechnologyOperationComponentCommentWasChanged() throws Exception { Long technologyOperationComponentId = 1L; String comment = "comment"; String technologyOperationComponentComment = "comment2"; given(technologyOperationComponent.getId()).willReturn(technologyOperationComponentId); given(technologyOperationComponentDD.get(technologyOperationComponentId)).willReturn(technologyOperationComponentFromDB); given(technologyOperationComponent.getStringField(TechnologyOperationComponentFields.COMMENT)).willReturn(comment); given(technologyOperationComponentFromDB.getStringField(TechnologyOperationComponentFields.COMMENT)).willReturn( technologyOperationComponentComment); EntityList techOperCompOperationalTasks = mockEntityList(Lists.newArrayList(techOperCompOperationalTask)); given( operationalTasksForOrdersService .getTechOperCompOperationalTasksForTechnologyOperationComponent(technologyOperationComponent)) .willReturn(techOperCompOperationalTasks); technologyOperationComponentHooksOTFO.changeDescriptionInOperationalTasksWhenChanged(technologyOperationComponentDD, technologyOperationComponent); Mockito.verify(operationalTask).setField(OperationalTaskFields.DESCRIPTION, comment); Mockito.verify(operationalTaskDD).save(operationalTask); }
### Question: OperationHooksOTFO { public void changedNameInOperationalTasksWhenChanged(final DataDefinition operationDD, final Entity operation) { Long operationId = operation.getId(); if (operationId == null) { return; } Entity operationFromDB = operationDD.get(operationId); String name = operation.getStringField(OperationFields.NAME); String operationName = operationFromDB.getStringField(OperationFields.NAME); if (!name.equals(operationName)) { changedNameInOperationalTasks(operation); } } void changedNameInOperationalTasksWhenChanged(final DataDefinition operationDD, final Entity operation); }### Answer: @Test public void shouldReturnIfEntityIdIsNull() throws Exception { Long operationId = null; String name = "name"; given(operation.getId()).willReturn(operationId); operationHooksOTFO.changedNameInOperationalTasksWhenChanged(operationDD, operation); Mockito.verify(operationalTask, Mockito.never()).setField(OperationalTaskFields.NAME, name); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Test public void shouldReturnWhenEntityNameIsTheSame() throws Exception { Long operationId = 1L; String name = "name"; String operationName = "name"; given(operation.getId()).willReturn(operationId); given(operationDD.get(operationId)).willReturn(operationFromDB); given(operation.getStringField(OperationFields.NAME)).willReturn(name); given(operationFromDB.getStringField(OperationFields.NAME)).willReturn(operationName); operationHooksOTFO.changedNameInOperationalTasksWhenChanged(operationDD, operation); Mockito.verify(operationalTask, Mockito.never()).setField(OperationalTaskFields.NAME, name); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Ignore @Test public void shouldChangeOperationalTaskNameWhenOperationNameWasChanged() throws Exception { Long operationId = 1L; String name = "name"; String operationName = "name2"; given(operation.getId()).willReturn(operationId); given(operationDD.get(operationId)).willReturn(operationFromDB); given(operation.getStringField(OperationFields.NAME)).willReturn(name); given(operationFromDB.getStringField(OperationFields.NAME)).willReturn(operationName); EntityList technologyOperationComponents = mockEntityList(Lists.newArrayList(technologyOperationComponent)); given(operationalTasksForOrdersService.getTechnologyOperationComponentsForOperation(operation)).willReturn( technologyOperationComponents); operationHooksOTFO.changedNameInOperationalTasksWhenChanged(operationDD, operation); Mockito.verify(operationalTask).setField(OperationalTaskFields.NAME, name); Mockito.verify(operationalTaskDD).save(operationalTask); }
### Question: OperationalTaskDetailsHooksOTFO { public void disableFieldsWhenOrderTypeIsSelected(final ViewDefinitionState view) { FieldComponent typeTaskField = (FieldComponent) view.getComponentByReference(OperationalTaskFields.TYPE_TASK); String typeTask = (String) typeTaskField.getFieldValue(); List<String> referenceBasicFields = Lists.newArrayList(OperationalTaskFields.NAME, OperationalTaskFields.PRODUCTION_LINE, OperationalTaskFields.DESCRIPTION); List<String> extendFields = Lists.newArrayList(OperationalTaskFieldsOTFO.ORDER, OperationalTaskFieldsOTFO.TECHNOLOGY_OPERATION_COMPONENT); if (operationalTasksForOrdersService.isOperationalTaskTypeTaskOtherCase(typeTask)) { changedStateField(view, referenceBasicFields, true); changedStateField(view, extendFields, false); clearFieldValue(view, extendFields); } else { changedStateField(view, referenceBasicFields, false); changedStateField(view, extendFields, true); } } void disableFieldsWhenOrderTypeIsSelected(final ViewDefinitionState view); void disableButtons(final ViewDefinitionState view); void setTechnology(final ViewDefinitionState view); void setTechnologyOperationComponent(final ViewDefinitionState view); }### Answer: @Test public void shouldDisabledFieldWhenTypeForOrderIsSelected() throws Exception { String typeTask = OperationalTaskTypeTaskOTFO.EXECUTION_OPERATION_IN_ORDER.getStringValue(); given(typeTaskField.getFieldValue()).willReturn(typeTask); given(operationalTasksForOrdersService.isOperationalTaskTypeTaskOtherCase(typeTask)).willReturn(false); operationalTaskDetailsHooksOTFO.disableFieldsWhenOrderTypeIsSelected(view); Mockito.verify(nameField).setEnabled(false); Mockito.verify(descriptionField).setEnabled(false); Mockito.verify(productionLineField).setEnabled(false); Mockito.verify(orderField).setEnabled(true); Mockito.verify(technologyOperationComponentField).setEnabled(true); } @Test public void shouldEnabledFieldWhenTypeOtherCaseIsSelected() throws Exception { String typeTask = OperationalTaskTypeTask.OTHER_CASE.getStringValue(); given(typeTaskField.getFieldValue()).willReturn(typeTask); given(operationalTasksForOrdersService.isOperationalTaskTypeTaskOtherCase(typeTask)).willReturn(true); operationalTaskDetailsHooksOTFO.disableFieldsWhenOrderTypeIsSelected(view); Mockito.verify(nameField).setEnabled(true); Mockito.verify(descriptionField).setEnabled(true); Mockito.verify(productionLineField).setEnabled(true); Mockito.verify(orderField).setEnabled(false); Mockito.verify(technologyOperationComponentField).setEnabled(false); }
### Question: OrderHooksOTFO { public void changedProductionLineInOperationalTasksWhenChanged(final DataDefinition orderDD, final Entity order) { Long orderId = order.getId(); if (orderId == null) { return; } Entity orderFromDB = orderDD.get(orderId); Entity productionLine = order.getBelongsToField(OrderFields.PRODUCTION_LINE); Entity orderProductionLine = orderFromDB.getBelongsToField(OrderFields.PRODUCTION_LINE); if ((productionLine == null) \|\| (orderProductionLine == null)) { return; } else { if (!orderProductionLine.getId().equals(productionLine.getId())) { changedProductionLineInOperationalTasks(orderFromDB, productionLine); } } } void changedProductionLineInOperationalTasksWhenChanged(final DataDefinition orderDD, final Entity order); }### Answer: @Test public void shouldReturnWhenEntityIdIsNull() throws Exception { Long orderId = null; given(order.getId()).willReturn(orderId); orderHooksOTFO.changedProductionLineInOperationalTasksWhenChanged(orderDD, order); } @Test public void shouldReturnWhenProductionLineIsTheSame() throws Exception { Long orderId = 1L; Long productionLineId = 1L; given(order.getId()).willReturn(orderId); given(orderDD.get(orderId)).willReturn(orderFromDB); given(order.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(productionLine); given(orderFromDB.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(productionLine); given(productionLine.getId()).willReturn(productionLineId); orderHooksOTFO.changedProductionLineInOperationalTasksWhenChanged(orderDD, order); Mockito.verify(operationalTask, Mockito.never()).setField(OrderFields.PRODUCTION_LINE, null); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Test public void shouldReturneWhenProductionLineIsNull() throws Exception { Long orderId = 1L; Long productionLineId = 1L; given(order.getId()).willReturn(orderId); given(orderDD.get(orderId)).willReturn(orderFromDB); given(order.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(productionLine); given(orderFromDB.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(null); given(productionLine.getId()).willReturn(productionLineId); orderHooksOTFO.changedProductionLineInOperationalTasksWhenChanged(orderDD, order); Mockito.verify(operationalTask, Mockito.never()).setField(OrderFields.PRODUCTION_LINE, productionLine); Mockito.verify(operationalTaskDD, Mockito.never()).save(operationalTask); } @Ignore @Test public void shouldChangeProductionLineWhenProductionLineWasChanged() throws Exception { Long orderId = 1L; Long productionLineId = 1L; Long orderProductionLineId = 2L; given(order.getId()).willReturn(orderId); given(orderDD.get(orderId)).willReturn(orderFromDB); given(order.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(productionLine); given(orderFromDB.getBelongsToField(OrderFields.PRODUCTION_LINE)).willReturn(orderProductionLine); given(productionLine.getId()).willReturn(productionLineId); given(orderProductionLine.getId()).willReturn(orderProductionLineId); EntityList operationalTasks = mockEntityList(Lists.newArrayList(operationalTask)); given(operationalTasksForOrdersService.getOperationalTasksForOrder(order)).willReturn(operationalTasks); orderHooksOTFO.changedProductionLineInOperationalTasksWhenChanged(orderDD, order); Mockito.verify(operationalTask).setField(OrderFields.PRODUCTION_LINE, productionLine); Mockito.verify(operationalTaskDD).save(operationalTask); }
### Question: ProductCatalogNumbersHooks { public boolean checkIfExistsCatalogNumberWithNumberAndCompany(final DataDefinition dataDefinition, final Entity entity) { SearchCriteriaBuilder criteria = dataDefinitionService .get(ProductCatalogNumbersConstants.PLUGIN_IDENTIFIER, ProductCatalogNumbersConstants.MODEL_PRODUCT_CATALOG_NUMBERS).find() .add(SearchRestrictions.eq(CATALOG_NUMBER, entity.getStringField(CATALOG_NUMBER))) .add(SearchRestrictions.belongsTo(COMPANY, entity.getBelongsToField(COMPANY))); if (entity.getId() != null) { criteria.add(SearchRestrictions.ne("id", entity.getId())); } List<Entity> catalogsNumbers = criteria.list().getEntities(); if (catalogsNumbers.isEmpty()) { return true; } else { entity.addGlobalError("productCatalogNumbers.productCatalogNumber.validationError.alreadyExistsCatalogNumerForCompany"); return false; } } boolean checkIfExistsCatalogNumberWithProductAndCompany(final DataDefinition dataDefinition, final Entity entity); boolean checkIfExistsCatalogNumberWithNumberAndCompany(final DataDefinition dataDefinition, final Entity entity); }### Answer: @Test public void shouldReturnTrueWhenEntityWithGivenNumberAndCompanyDoesnotExistsInDB() throws Exception { SearchCriterion criterion1 = SearchRestrictions.eq(CATALOG_NUMBER, entity.getStringField(CATALOG_NUMBER)); SearchCriterion criterion2 = SearchRestrictions.belongsTo(ProductCatalogNumberFields.COMPANY, company); given(entity.getId()).willReturn(null); given(criteria.add(criterion1)).willReturn(criteria); given(criteria.add(criterion2)).willReturn(criteria); given(criteria.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(productCatalogNumbers); given(productCatalogNumbers.isEmpty()).willReturn(true); boolean result = productCatalogNumbersHooks.checkIfExistsCatalogNumberWithNumberAndCompany(dataDefinition, entity); Assert.assertTrue(result); } @Test public void shouldReturnFalseWhenEntityWithGivenNumberAndCompanyDoesExistsInDB() throws Exception { SearchCriterion criterion1 = SearchRestrictions.eq(CATALOG_NUMBER, entity.getStringField(CATALOG_NUMBER)); SearchCriterion criterion2 = SearchRestrictions.belongsTo(ProductCatalogNumberFields.COMPANY, company); given(entity.getId()).willReturn(null); given(criteria.add(criterion1)).willReturn(criteria); given(criteria.add(criterion2)).willReturn(criteria); given(criteria.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(productCatalogNumbers); given(productCatalogNumbers.isEmpty()).willReturn(false); boolean result = productCatalogNumbersHooks.checkIfExistsCatalogNumberWithNumberAndCompany(dataDefinition, entity); Assert.assertFalse(result); Mockito.verify(entity).addGlobalError( "productCatalogNumbers.productCatalogNumber.validationError.alreadyExistsCatalogNumerForCompany"); }
### Question: OperationDurationDetailsInOrderDetailsHooksOTFO { public void disableCreateButton(final ViewDefinitionState view) { WindowComponent window = (WindowComponent) view.getComponentByReference(L_WINDOW); RibbonGroup operationalTasks = window.getRibbon().getGroupByName(L_OPERATIONAL_TASKS); RibbonActionItem createOperationalTasks = operationalTasks.getItemByName(L_CREATE_OPERATIONAL_TASKS); if (isGenerated(view) && orderHasTechnologyAndCorrectState(view)) { createOperationalTasks.setEnabled(true); } else { createOperationalTasks.setEnabled(false); } createOperationalTasks.requestUpdate(true); } void disableCreateButton(final ViewDefinitionState view); }### Answer: @Test public void shouldEnableButtonWhenIsGeneratedAndOrderStateIsAccepted() throws Exception { String generatedEndDate = "01-02-2012"; given(generatedEndDateField.getFieldValue()).willReturn(generatedEndDate); given(order.getStringField(OrderFields.STATE)).willReturn(OrderStateStringValues.ACCEPTED); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(technology); operationDurationDetailsInOrderDetailsHooksOTFO.disableCreateButton(view); Mockito.verify(createOperationalTasks).setEnabled(true); } @Test public void shouldDisableButtonWhenIsNotGeneratedAndOrderStateIsInProgress() throws Exception { String generatedEndDate = ""; given(generatedEndDateField.getFieldValue()).willReturn(generatedEndDate); given(order.getStringField(OrderFields.STATE)).willReturn(OrderStateStringValues.IN_PROGRESS); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(technology); operationDurationDetailsInOrderDetailsHooksOTFO.disableCreateButton(view); Mockito.verify(createOperationalTasks).setEnabled(false); } @Test public void shouldDisableButtonWhenIsNotGeneratedAndOrderStateIsIncorrect() throws Exception { String generatedEndDate = ""; given(generatedEndDateField.getFieldValue()).willReturn(generatedEndDate); given(order.getStringField(OrderFields.STATE)).willReturn(OrderStateStringValues.ABANDONED); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(technology); operationDurationDetailsInOrderDetailsHooksOTFO.disableCreateButton(view); Mockito.verify(createOperationalTasks).setEnabled(false); } @Test public void shouldDisableFieldWhenIsGeneratedAndOrderStateIsIncorrect() throws Exception { String generatedEndDate = "01-02-2012"; given(generatedEndDateField.getFieldValue()).willReturn(generatedEndDate); given(order.getStringField(OrderFields.STATE)).willReturn(OrderStateStringValues.DECLINED); given(order.getBelongsToField(OrderFields.TECHNOLOGY)).willReturn(technology); operationDurationDetailsInOrderDetailsHooksOTFO.disableCreateButton(view); Mockito.verify(createOperationalTasks).setEnabled(false); }
### 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 showPreviousOrder(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { LookupComponent previousOrderLookup = (LookupComponent) view.getComponentByReference(OrderFieldsLCNFO.PREVIOUS_ORDER); Long previousOrderId = (Long) previousOrderLookup.getFieldValue(); if (previousOrderId == null) { return; } Map<String, Object> parameters = Maps.newHashMap(); parameters.put("form.id", previousOrderId); String url = "../page/orders/orderDetails.html"; view.redirectTo(url, false, true, parameters); } 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 shouldNotRedirectToPreviousOrderIfPreviousOrderIsNull() { stubLookup(previousOrderLookup, null); lineChangeoverNormsForOrderDetailsListeners.showPreviousOrder(view, null, null); verify(view, never()).redirectTo(anyString(), anyBoolean(), anyBoolean(), anyMap()); } @Test public void shouldRedirectToPreviousOrderIfPreviousOrderIsNotNull() { stubLookup(previousOrderLookup, entityWithId); lineChangeoverNormsForOrderDetailsListeners.showPreviousOrder(view, null, null); String url = "../page/orders/orderDetails.html"; verify(view).redirectTo(eq(url), anyBoolean(), anyBoolean(), parametersCaptor.capture()); Map<String, Object> usedParameters = parametersCaptor.getValue(); assertEquals(L_ID, usedParameters.get("form.id")); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public final void showBestFittingLineChangeoverNorm(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { FieldComponent lineChangeoverNormField = (FieldComponent) view .getComponentByReference(OrderFieldsLCNFO.LINE_CHANGEOVER_NORM); Long lineChangeoverNormId = (Long) lineChangeoverNormField.getFieldValue(); if (lineChangeoverNormId == null) { return; } Map<String, Object> parameters = Maps.newHashMap(); parameters.put("form.id", lineChangeoverNormId); String url = "../page/lineChangeoverNorms/lineChangeoverNormsDetails.html"; view.redirectTo(url, false, true, parameters); } 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 shouldNotRedirectToBestFittingLineChangeoverNormIfLineChangeoverIsNull() { stubLookup(lineChangeoverNormLookup, null); lineChangeoverNormsForOrderDetailsListeners.showBestFittingLineChangeoverNorm(view, null, null); verify(view, never()).redirectTo(anyString(), anyBoolean(), anyBoolean(), anyMap()); } @Test public void shouldRedirectToBestFittingLineChangeoverNormIfLineChangeoverNormIsNotNull() { stubLookup(lineChangeoverNormLookup, entityWithId); lineChangeoverNormsForOrderDetailsListeners.showBestFittingLineChangeoverNorm(view, null, null); String url = "../page/lineChangeoverNorms/lineChangeoverNormsDetails.html"; verify(view).redirectTo(eq(url), anyBoolean(), anyBoolean(), parametersCaptor.capture()); Map<String, Object> usedParameters = parametersCaptor.getValue(); assertEquals(L_ID, usedParameters.get("form.id")); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public final void showLineChangeoverNormForGroup(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { FieldComponent previousOrderTechnologyGroupNumberField = (FieldComponent) view .getComponentByReference("previousOrderTechnologyGroupNumber"); FieldComponent technologyGroupNumberField = (FieldComponent) view.getComponentByReference("technologyGroupNumber"); String previousOrderTechnologyGroupNumber = (String) previousOrderTechnologyGroupNumberField.getFieldValue(); String technologyGroupNumber = (String) technologyGroupNumberField.getFieldValue(); if (StringUtils.isEmpty(previousOrderTechnologyGroupNumber) \|\| StringUtils.isEmpty(technologyGroupNumber)) { return; } Map<String, String> filters = Maps.newHashMap(); filters.put("fromTechnologyGroup", previousOrderTechnologyGroupNumber); filters.put("toTechnologyGroup", technologyGroupNumber); Map<String, Object> gridOptions = Maps.newHashMap(); gridOptions.put(L_FILTERS, filters); Map<String, Object> parameters = Maps.newHashMap(); parameters.put(L_GRID_OPTIONS, gridOptions); parameters.put(L_WINDOW_ACTIVE_MENU, "technology.lineChangeoverNorms"); String url = "../page/lineChangeoverNorms/lineChangeoverNormsList.html"; view.redirectTo(url, false, true, parameters); } 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 shouldNotRedirectToLineChangeoverNormForGroupIfTechnologyGroupNumbersAreEmpty() { given(previousOrderTechnologyGroupNumberField.getFieldValue()).willReturn(null); given(technologyGroupNumberField.getFieldValue()).willReturn(null); lineChangeoverNormsForOrderDetailsListeners.showLineChangeoverNormForGroup(view, null, null); verify(view, never()).redirectTo(anyString(), anyBoolean(), anyBoolean(), anyMap()); } @Test public void shouldRedirectToLineChangeoverNormForGroupIfTechnologyGroupNumbersAreNotEmpty() { given(previousOrderTechnologyGroupNumberField.getFieldValue()).willReturn(L_TECHNOLOGY_GROUP_NUMBER); given(technologyGroupNumberField.getFieldValue()).willReturn(L_TECHNOLOGY_GROUP_NUMBER); lineChangeoverNormsForOrderDetailsListeners.showLineChangeoverNormForGroup(view, null, null); String url = "../page/lineChangeoverNorms/lineChangeoverNormsList.html"; verify(view).redirectTo(eq(url), anyBoolean(), anyBoolean(), parametersCaptor.capture()); Map<String, Object> usedParameters = parametersCaptor.getValue(); assertEquals(2, usedParameters.size()); assertEquals("technology.lineChangeoverNorms", usedParameters.get(L_WINDOW_ACTIVE_MENU)); Map<String, Object> gridOptions = (Map<String, Object>) usedParameters.get(L_GRID_OPTIONS); assertEquals(1, gridOptions.size()); Map<String, Object> filters = (Map<String, Object>) gridOptions.get(L_FILTERS); assertEquals(2, filters.size()); assertEquals(L_TECHNOLOGY_GROUP_NUMBER, filters.get("fromTechnologyGroup")); assertEquals(L_TECHNOLOGY_GROUP_NUMBER, filters.get("toTechnologyGroup")); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public final void showLineChangeoverNormForTechnology(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { FieldComponent previousOrderTechnologyNumberField = (FieldComponent) view .getComponentByReference("previousOrderTechnologyNumber"); FieldComponent technologyNumberField = (FieldComponent) view.getComponentByReference("technologyNumber"); String previousOrderTechnologyNumber = (String) previousOrderTechnologyNumberField.getFieldValue(); String technologyNumber = (String) technologyNumberField.getFieldValue(); if (StringUtils.isEmpty(previousOrderTechnologyNumber) \|\| StringUtils.isEmpty(technologyNumber)) { return; } Map<String, String> filters = Maps.newHashMap(); filters.put("fromTechnology", previousOrderTechnologyNumber); filters.put("toTechnology", technologyNumber); Map<String, Object> gridOptions = Maps.newHashMap(); gridOptions.put(L_FILTERS, filters); Map<String, Object> parameters = Maps.newHashMap(); parameters.put(L_GRID_OPTIONS, gridOptions); parameters.put(L_WINDOW_ACTIVE_MENU, "technology.lineChangeoverNorms"); String url = "../page/lineChangeoverNorms/lineChangeoverNormsList.html"; view.redirectTo(url, false, true, parameters); } 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 shouldNotRedirectToLineChangeoverNormsForTechnologyIfTechnologyNumbersAreEmpty() { given(previousOrderTechnologyNumberField.getFieldValue()).willReturn(null); given(technologyNumberField.getFieldValue()).willReturn(null); lineChangeoverNormsForOrderDetailsListeners.showLineChangeoverNormForTechnology(view, null, null); verify(view, never()).redirectTo(anyString(), anyBoolean(), anyBoolean(), anyMap()); } @Test public void shouldRedirectToLineChangeoverNormsForTechnologyIfTechnologyNumbersAreNotEmpty() { given(previousOrderTechnologyNumberField.getFieldValue()).willReturn(L_TECHNOLOGY_NUMBER); given(technologyNumberField.getFieldValue()).willReturn(L_TECHNOLOGY_NUMBER); lineChangeoverNormsForOrderDetailsListeners.showLineChangeoverNormForTechnology(view, null, null); String url = "../page/lineChangeoverNorms/lineChangeoverNormsList.html"; verify(view).redirectTo(eq(url), anyBoolean(), anyBoolean(), parametersCaptor.capture()); Map<String, Object> usedParameters = parametersCaptor.getValue(); assertEquals(2, usedParameters.size()); assertEquals("technology.lineChangeoverNorms", usedParameters.get(L_WINDOW_ACTIVE_MENU)); Map<String, Object> gridOptions = (Map<String, Object>) usedParameters.get(L_GRID_OPTIONS); assertEquals(1, gridOptions.size()); Map<String, Object> filters = (Map<String, Object>) gridOptions.get(L_FILTERS); assertEquals(2, filters.size()); assertEquals(L_TECHNOLOGY_GROUP_NUMBER, filters.get("fromTechnology")); assertEquals(L_TECHNOLOGY_GROUP_NUMBER, filters.get("toTechnology")); }
### Question: LineChangeoverNormsForOrderDetailsListeners { public final void checkIfOrderHasCorrectStateAndIsPrevious(final ViewDefinitionState view, final ComponentState componentState, final String[] args) { LookupComponent previousOrderLookup = (LookupComponent) view.getComponentByReference(OrderFieldsLCNFO.PREVIOUS_ORDER); LookupComponent orderLookup = (LookupComponent) view.getComponentByReference(OrderFieldsLCNFO.ORDER); Entity previousOrder = previousOrderLookup.getEntity(); Entity order = orderLookup.getEntity(); if (!lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(previousOrder, order)) { previousOrderLookup.addMessage("orders.order.previousOrder.message.orderIsIncorrect", ComponentState.MessageType.FAILURE); } } 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 shouldNotAddMessageWhenOrdersAreNotSpecified() { stubLookup(previousOrderLookup, null); stubLookup(orderLookup, null); given(lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(null, null)).willReturn(true); lineChangeoverNormsForOrderDetailsListeners.checkIfOrderHasCorrectStateAndIsPrevious(view, null, null); verify(previousOrderLookup, never()).addMessage(anyString(), eq(ComponentState.MessageType.FAILURE)); } @Test public void shouldNotAddMessageWhenPreviousOrderIsCorrect() { stubLookup(previousOrderLookup, entityWithId); stubLookup(orderLookup, entityWithId); given(lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(entityWithId, entityWithId)).willReturn( true); lineChangeoverNormsForOrderDetailsListeners.checkIfOrderHasCorrectStateAndIsPrevious(view, null, null); verify(previousOrderLookup, never()).addMessage(anyString(), eq(ComponentState.MessageType.FAILURE)); } @Test public void shouldAddMessageWhenPreviousOrderIsIncorrect() { stubLookup(previousOrderLookup, entityWithId); stubLookup(orderLookup, entityWithId); given(lineChangeoverNormsForOrdersService.previousOrderEndsBeforeOrIsWithdrawed(entityWithId, entityWithId)).willReturn( false); lineChangeoverNormsForOrderDetailsListeners.checkIfOrderHasCorrectStateAndIsPrevious(view, null, null); verify(previousOrderLookup).addMessage(anyString(), eq(ComponentState.MessageType.FAILURE)); }
### Question: ProductCatalogNumbersHooks { public boolean checkIfExistsCatalogNumberWithProductAndCompany(final DataDefinition dataDefinition, final Entity entity) { SearchCriteriaBuilder criteria = dataDefinitionService .get(ProductCatalogNumbersConstants.PLUGIN_IDENTIFIER, ProductCatalogNumbersConstants.MODEL_PRODUCT_CATALOG_NUMBERS).find() .add(SearchRestrictions.belongsTo(PRODUCT, entity.getBelongsToField(PRODUCT))) .add(SearchRestrictions.belongsTo(COMPANY, entity.getBelongsToField(COMPANY))); if (entity.getId() != null) { criteria.add(SearchRestrictions.ne("id", entity.getId())); } List<Entity> catalogsNumbers = criteria.list().getEntities(); if (catalogsNumbers.isEmpty()) { return true; } else { entity.addGlobalError("productCatalogNumbers.productCatalogNumber.validationError.alreadyExistsProductForCompany"); return false; } } boolean checkIfExistsCatalogNumberWithProductAndCompany(final DataDefinition dataDefinition, final Entity entity); boolean checkIfExistsCatalogNumberWithNumberAndCompany(final DataDefinition dataDefinition, final Entity entity); }### Answer: @Test public void shouldReturnTrueWhenEntityWithGivenProductAndCompanyDoesnotExistsInDB() throws Exception { SearchCriterion criterion1 = SearchRestrictions.eq(CATALOG_NUMBER, entity.getStringField(CATALOG_NUMBER)); SearchCriterion criterion2 = SearchRestrictions.belongsTo(PRODUCT, entity.getBelongsToField(PRODUCT)); given(entity.getId()).willReturn(null); given(criteria.add(criterion1)).willReturn(criteria); given(criteria.add(criterion2)).willReturn(criteria); given(criteria.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(productCatalogNumbers); given(productCatalogNumbers.isEmpty()).willReturn(true); boolean result = productCatalogNumbersHooks.checkIfExistsCatalogNumberWithProductAndCompany(dataDefinition, entity); Assert.assertTrue(result); } @Test public void shouldReturnFalseWhenEntityWithGivenProductAndCompanyDoesExistsInDB() throws Exception { SearchCriterion criterion1 = SearchRestrictions.eq(CATALOG_NUMBER, entity.getStringField(CATALOG_NUMBER)); SearchCriterion criterion2 = SearchRestrictions.belongsTo(PRODUCT, entity.getBelongsToField(PRODUCT)); given(entity.getId()).willReturn(null); given(criteria.add(criterion1)).willReturn(criteria); given(criteria.add(criterion2)).willReturn(criteria); given(criteria.list()).willReturn(searchResult); given(searchResult.getEntities()).willReturn(productCatalogNumbers); given(productCatalogNumbers.isEmpty()).willReturn(false); boolean result = productCatalogNumbersHooks.checkIfExistsCatalogNumberWithProductAndCompany(dataDefinition, entity); Assert.assertFalse(result); Mockito.verify(entity).addGlobalError( "productCatalogNumbers.productCatalogNumber.validationError.alreadyExistsProductForCompany"); }
### 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: TechnologyOperationComponentHooksTS { public void copySubstractingFieldFromLowerInstance(final DataDefinition technologyOperationComponentDD, final Entity technologyOperationComponent) { if (!shouldCopyFromLowerInstance(technologyOperationComponent)) { return; } Entity operation = technologyOperationComponent.getBelongsToField(OPERATION); if (operation != null) { technologyOperationComponent.setField(IS_SUBCONTRACTING, operation.getBooleanField(IS_SUBCONTRACTING)); } } void copySubstractingFieldFromLowerInstance(final DataDefinition technologyOperationComponentDD, final Entity technologyOperationComponent); }### Answer: @Test public void shouldSetTrueFromLowerInstance() throws Exception { when(technologyOperationComponent.getField(IS_SUBCONTRACTING)).thenReturn(null); when(operation.getBooleanField(IS_SUBCONTRACTING)).thenReturn(true); technologyOperationComponentHooksTS.copySubstractingFieldFromLowerInstance(technologyOperationComponentDD, technologyOperationComponent); Mockito.verify(technologyOperationComponent).setField(IS_SUBCONTRACTING, true); } @Test public void shouldSetFalseFromLowerInstance() throws Exception { when(technologyOperationComponent.getField(IS_SUBCONTRACTING)).thenReturn(null); when(operation.getBooleanField("isSubcontracting")).thenReturn(false); technologyOperationComponentHooksTS.copySubstractingFieldFromLowerInstance(technologyOperationComponentDD, technologyOperationComponent); Mockito.verify(technologyOperationComponent).setField(IS_SUBCONTRACTING, false); } @Test public final void shouldCopyFalseValueFromFieldFromTheSameLevel() throws Exception { when(technologyOperationComponent.getBooleanField(IS_SUBCONTRACTING)).thenReturn(false); technologyOperationComponentHooksTS.copySubstractingFieldFromLowerInstance(technologyOperationComponentDD, technologyOperationComponent); boolean isSubcontracting = technologyOperationComponent.getBooleanField(IS_SUBCONTRACTING); Assert.assertEquals(false, isSubcontracting); } @Test public final void shouldCopyTrueValueFromFieldFromTheSameLevel() throws Exception { when(technologyOperationComponent.getBooleanField(IS_SUBCONTRACTING)).thenReturn(true); technologyOperationComponentHooksTS.copySubstractingFieldFromLowerInstance(technologyOperationComponentDD, technologyOperationComponent); boolean isSubcontracting = technologyOperationComponent.getBooleanField(IS_SUBCONTRACTING); Assert.assertEquals(true, isSubcontracting); }
### 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); }
### Question: MasterOrderProductDetailsHooks { public void showErrorWhenCumulatedQuantity(final ViewDefinitionState view) { FormComponent masterOrderProductForm = (FormComponent) view.getComponentByReference(L_FORM); Entity masterOrderProduct = masterOrderProductForm.getPersistedEntityWithIncludedFormValues(); if ((masterOrderProduct == null) \|\| !masterOrderProduct.isValid()) { return; } Entity masterOrder = masterOrderProduct.getBelongsToField(MasterOrderProductFields.MASTER_ORDER); BigDecimal cumulatedQuantity = masterOrderProduct.getDecimalField(MasterOrderProductFields.CUMULATED_ORDER_QUANTITY); BigDecimal masterOrderQuantity = masterOrderProduct.getDecimalField(MasterOrderProductFields.MASTER_ORDER_QUANTITY); if ((cumulatedQuantity != null) && (masterOrderQuantity != null) && (cumulatedQuantity.compareTo(masterOrderQuantity) == -1)) { masterOrderProductForm.addMessage("masterOrders.masterOrder.masterOrderCumulatedQuantityField.wrongQuantity", MessageType.INFO, false); } } void fillUnitField(final ViewDefinitionState view); void fillDefaultTechnology(final ViewDefinitionState view); void showErrorWhenCumulatedQuantity(final ViewDefinitionState view); }### Answer: @Test public final void shouldShowMessageError() { BigDecimal cumulatedOrderQuantity = BigDecimal.ONE; BigDecimal masterOrderQuantity = BigDecimal.TEN; given(masterOrderProduct.isValid()).willReturn(true); given(masterOrderProduct.getDecimalField(MasterOrderProductFields.CUMULATED_ORDER_QUANTITY)).willReturn( cumulatedOrderQuantity); given(masterOrderProduct.getDecimalField(MasterOrderProductFields.MASTER_ORDER_QUANTITY)).willReturn(masterOrderQuantity); masterOrderProductDetailsHooks.showErrorWhenCumulatedQuantity(view); verify(masterOrderProductForm).addMessage("masterOrders.masterOrder.masterOrderCumulatedQuantityField.wrongQuantity", MessageType.INFO, false); } @Test public final void shouldDonotShowMessageError() { BigDecimal cumulatedOrderQuantity = BigDecimal.TEN; BigDecimal masterOrderQuantity = BigDecimal.ONE; given(masterOrderProduct.isValid()).willReturn(true); given(masterOrderProduct.getDecimalField(MasterOrderProductFields.CUMULATED_ORDER_QUANTITY)).willReturn( cumulatedOrderQuantity); given(masterOrderProduct.getDecimalField(MasterOrderProductFields.MASTER_ORDER_QUANTITY)).willReturn(masterOrderQuantity); masterOrderProductDetailsHooks.showErrorWhenCumulatedQuantity(view); verify(masterOrderProductForm, Mockito.never()).addMessage( "masterOrders.masterOrder.masterOrderCumulatedQuantityField.wrongQuantity", MessageType.INFO, false); }
### Question: OrderValidatorsMO { public boolean checkProductAndTechnology(final DataDefinition orderDD, final Entity order) { Entity masterOrder = order.getBelongsToField(MASTER_ORDER); if (masterOrder == null \|\| masterOrder.getHasManyField(MasterOrderFields.MASTER_ORDER_PRODUCTS).isEmpty()) { return true; } return checkIfOrderMatchesAnyOfMasterOrderProductsWithTechnology(order, masterOrder); } boolean checkOrderNumber(final DataDefinition orderDD, final Entity order); boolean checkCompanyAndDeadline(final DataDefinition orderDD, final Entity order); boolean checkProductAndTechnology(final DataDefinition orderDD, final Entity order); }### Answer: @Test public final void shouldReturnFalseIfNoneOfMasterOrderProductMatches() { stubMasterOrderProducts(NOT_EMPTY_ENTITY_LIST); SearchCriteriaBuilder scb = mockCriteriaBuilder(EMPTY_ENTITY_LIST); given(masterDD.find()).willReturn(scb); boolean isValid = orderValidatorsMO.checkProductAndTechnology(orderDD, order); Assert.assertFalse(isValid); Mockito.verify(scb).add(technologyIsEmptyOrMatchTechPrototypeRestriction); } @Test public final void shouldReturnTrueIfSomeMasterOrderProductMatches() { stubMasterOrderProducts(NOT_EMPTY_ENTITY_LIST); SearchCriteriaBuilder scb = mockCriteriaBuilder(NOT_EMPTY_ENTITY_LIST); given(masterDD.find()).willReturn(scb); boolean isValid = orderValidatorsMO.checkProductAndTechnology(orderDD, order); Assert.assertTrue(isValid); Mockito.verify(scb).add(technologyIsEmptyOrMatchTechPrototypeRestriction); } @Test public final void shouldReturnTrueIfSomeMasterOrderProductMatches2() { stubMasterOrderProducts(NOT_EMPTY_ENTITY_LIST); stubOrderTechnologyPrototype(null); SearchCriteriaBuilder scb = mockCriteriaBuilder(NOT_EMPTY_ENTITY_LIST); given(masterDD.find()).willReturn(scb); boolean isValid = orderValidatorsMO.checkProductAndTechnology(orderDD, order); Assert.assertTrue(isValid); Mockito.verify(scb).add(technologyIsNullRestriction); } @Test public final void shouldReturnTrueWhenMasterOrderIsNotSpecified() { given(order.getBelongsToField(MASTER_ORDER)).willReturn(null); boolean result = orderValidatorsMO.checkProductAndTechnology(orderDD, order); Assert.assertEquals(true, result); }
### Question: OrderValidatorsMO { public boolean checkCompanyAndDeadline(final DataDefinition orderDD, final Entity order) { boolean isValid = true; Entity masterOrder = order.getBelongsToField(MASTER_ORDER); if (masterOrder == null) { return isValid; } if (!checkIfBelongToFieldIsTheSame(order, masterOrder, COMPANY)) { Entity company = masterOrder.getBelongsToField(COMPANY); order.addError(orderDD.getField(COMPANY), "masterOrders.order.masterOrder.company.fieldIsNotTheSame", createInfoAboutEntity(company, "company")); isValid = false; } if (!checkIfDeadlineIsCorrect(order, masterOrder)) { Date deadline = (Date) masterOrder.getField(DEADLINE); order.addError( orderDD.getField(DEADLINE), "masterOrders.order.masterOrder.deadline.fieldIsNotTheSame", deadline == null ? translationService.translate("masterOrders.order.masterOrder.deadline.hasNotDeadline", Locale.getDefault()) : DateUtils.toDateTimeString(deadline)); isValid = false; } return isValid; } boolean checkOrderNumber(final DataDefinition orderDD, final Entity order); boolean checkCompanyAndDeadline(final DataDefinition orderDD, final Entity order); boolean checkProductAndTechnology(final DataDefinition orderDD, final Entity order); }### Answer: @Test public final void shouldCheckCompanyAndDeadlineReturnTrueWhenMasterOrderIsNotSpecified() { given(order.getBelongsToField(OrderFieldsMO.MASTER_ORDER)).willReturn(null); boolean result = orderValidatorsMO.checkCompanyAndDeadline(orderDD, order); Assert.assertTrue(result); }
### Question: OrderValidatorsMO { public boolean checkOrderNumber(final DataDefinition orderDD, final Entity order) { Entity masterOrder = order.getBelongsToField(MASTER_ORDER); if (masterOrder == null) { return true; } if (!masterOrder.getBooleanField(ADD_MASTER_PREFIX_TO_NUMBER)) { return true; } String masterOrderNumber = masterOrder.getStringField(MasterOrderFields.NUMBER); String orderNumber = order.getStringField(OrderFields.NUMBER); if (!orderNumber.startsWith(masterOrderNumber)) { order.addError(orderDD.getField(OrderFields.NUMBER), "masterOrders.order.number.numberHasNotPrefix", masterOrderNumber); return false; } return true; } boolean checkOrderNumber(final DataDefinition orderDD, final Entity order); boolean checkCompanyAndDeadline(final DataDefinition orderDD, final Entity order); boolean checkProductAndTechnology(final DataDefinition orderDD, final Entity order); }### Answer: @Test public final void shouldCheckOrderNumberReturnTrueWhenMasterOrderIsNotSpecified() { given(order.getBelongsToField(OrderFieldsMO.MASTER_ORDER)).willReturn(null); boolean result = orderValidatorsMO.checkOrderNumber(orderDD, order); Assert.assertEquals(true, result); } @Test public final void shouldCheckOrderNumberReturnTrueWhenAddPrefixIsFalse() { given(order.getBelongsToField(OrderFieldsMO.MASTER_ORDER)).willReturn(masterOrder); given(masterOrder.getBooleanField(MasterOrderFields.ADD_MASTER_PREFIX_TO_NUMBER)).willReturn(false); boolean result = orderValidatorsMO.checkOrderNumber(orderDD, order); Assert.assertEquals(true, result); } @Test public final void shouldCheckOrderNumberReturnFalseWhenNumberIsIncorrect() { String masterOrderNumber = "ZL"; String orderNumber = "ZXS"; given(order.getBelongsToField(OrderFieldsMO.MASTER_ORDER)).willReturn(masterOrder); given(masterOrder.getBooleanField(MasterOrderFields.ADD_MASTER_PREFIX_TO_NUMBER)).willReturn(true); given(masterOrder.getStringField(MasterOrderFields.NUMBER)).willReturn(masterOrderNumber); given(order.getStringField(OrderFields.NUMBER)).willReturn(orderNumber); boolean result = orderValidatorsMO.checkOrderNumber(orderDD, order); Assert.assertEquals(false, result); } @Test public final void shouldCheckOrderNumberReturnTrueWhenNumberIsCorrect() { String masterOrderNumber = "ZL"; String orderNumber = "ZLSADS"; given(order.getBelongsToField(OrderFieldsMO.MASTER_ORDER)).willReturn(masterOrder); given(masterOrder.getBooleanField(MasterOrderFields.ADD_MASTER_PREFIX_TO_NUMBER)).willReturn(true); given(masterOrder.getStringField(MasterOrderFields.NUMBER)).willReturn(masterOrderNumber); given(order.getStringField(OrderFields.NUMBER)).willReturn(orderNumber); boolean result = orderValidatorsMO.checkOrderNumber(orderDD, order); Assert.assertEquals(true, result); }
### Question: OperationalTaskDetailsListenersOTFOOverrideUtil { public void setOperationalTaskNameDescriptionAndProductionLineForSubcontracted(final ViewDefinitionState view) { LookupComponent orderLookup = (LookupComponent) view.getComponentByReference(OperationalTaskFieldsOTFO.ORDER); LookupComponent technologyOperationComponentLookup = (LookupComponent) view .getComponentByReference(L_TECHNOLOGY_OPERATION_COMPONENT); FieldComponent nameField = (FieldComponent) view.getComponentByReference(OperationalTaskFields.NAME); FieldComponent descriptionField = (FieldComponent) view.getComponentByReference(OperationalTaskFields.DESCRIPTION); LookupComponent productionLineLookup = (LookupComponent) view .getComponentByReference(OperationalTaskFields.PRODUCTION_LINE); Entity order = orderLookup.getEntity(); Entity technologyOperationComponent = technologyOperationComponentLookup.getEntity(); if ((order == null) \|\| (technologyOperationComponent == null) \|\| isSubcontracting(technologyOperationComponent)) { nameField.setFieldValue(null); descriptionField.setFieldValue(null); productionLineLookup.setFieldValue(null); nameField.requestComponentUpdateState(); descriptionField.requestComponentUpdateState(); productionLineLookup.requestComponentUpdateState(); } } void setOperationalTaskNameDescriptionAndProductionLineForSubcontracted(final ViewDefinitionState view); }### Answer: @Test public void shouldntOperationalTaskNameDescriptionAndProductionLineForSubcontractedWhenIsSubcontracting() throws Exception { given(orderLookup.getEntity()).willReturn(order); given(technologyOperationComponentLookup.getEntity()).willReturn(technologyOperationComponent); given(technologyOperationComponent.getBooleanField(TechnologyInstanceOperCompFieldsTS.IS_SUBCONTRACTING)) .willReturn(true); operationalTaskDetailsListenersOTFOOverrideUtil.setOperationalTaskNameDescriptionAndProductionLineForSubcontracted(view); Mockito.verify(nameField).setFieldValue(null); Mockito.verify(descriptionField).setFieldValue(null); Mockito.verify(productionLineLookup).setFieldValue(null); } @Test public void shouldntOperationalTaskNameDescriptionAndProductionLineForSubcontractedWhenTechnologyOperationComponentIsNull() throws Exception { given(orderLookup.getEntity()).willReturn(order); given(technologyOperationComponentLookup.getEntity()).willReturn(null); given(technologyOperationComponent.getBooleanField(TechnologyInstanceOperCompFieldsTS.IS_SUBCONTRACTING)).willReturn( false); operationalTaskDetailsListenersOTFOOverrideUtil.setOperationalTaskNameDescriptionAndProductionLineForSubcontracted(view); Mockito.verify(descriptionField).setFieldValue(null); Mockito.verify(nameField).setFieldValue(null); Mockito.verify(productionLineLookup).setFieldValue(null); }

Subsets and Splits

No saved queries yet

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