############################################################################## # # Copyright (c) 2005-2008 Nexedi SARL and Contributors. All Rights Reserved. # Sebastien Robin <seb@nexedi.com> # Romain Courteaud <romain@nexedi.com> # Lukasz Nowak <lukasz.nowak@ventis.com.pl> # # WARNING: This program as such is intended to be used by professional # programmers who take the whole responsability of assessing all potential # consequences resulting from its eventual inadequacies and bugs # End users who are looking for a ready-to-use solution with commercial # garantees and support are strongly adviced to contract a Free Software # Service Company # # This program is Free Software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # ############################################################################## import unittest import transaction from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase from zLOG import LOG from Products.ERP5Type.tests.Sequence import SequenceList from Products.CMFCore.utils import getToolByName from testLegacyOrder import TestOrderMixin class TestProductionOrderMixin(TestOrderMixin): run_all_test = 1 resource_portal_type = 'Product' order_portal_type = 'Production Order' order_line_portal_type = 'Production Order Line' order_cell_portal_type = 'Production Order Cell' supply_chain_portal_type = 'Supply Chain' supply_node_portal_type = 'Supply Node' supply_link_portal_type = 'Supply Link' component_portal_type = 'Component' transformation_portal_type = 'Transformation' transformed_resource_portal_type = \ 'Transformation Transformed Resource' operation_line_portal_type = 'Transformation Operation' operation_category_list = ['operation1', 'operation2'] colour_variation_portal_type = 'Product Individual Variation' morphology_variation_portal_type = 'Product Individual Variation' colour_list = ['green','blue'] mrp_size_list = ['Man','Woman'] def getBusinessTemplateList(self): """ """ return ('erp5_base','erp5_pdm', 'erp5_trade', 'erp5_mrp', 'erp5_accounting', 'erp5_invoicing', 'erp5_simulation', 'erp5_legacy') def setUpPreferences(self): portal = self.getPortal() preferences = getToolByName(portal,'portal_preferences') system_preference = preferences.newContent( portal_type = 'System Preference' ) system_preference.edit( preferred_product_individual_variation_base_category = ('variation',), preferred_component_individual_variation_base_category = ('variation',), preferred_product_variation_base_category = ('industrial_phase', 'colour', 'size'), preferred_component_variation_base_category = ('colour', 'size'), priority = 1, ) system_preference.enable() transaction.commit() self.tic() def afterSetUp(self): TestOrderMixin.afterSetUp(self) self.setUpPreferences() def createCategories(self): """ Light install create only base categories, so we create some categories for testing them """ TestOrderMixin.createCategories(self) operation_category_list = ['operation1', 'operation2'] if len(self.category_tool.operation.contentValues()) == 0: for category_id in operation_category_list: o = self.category_tool.operation.newContent( portal_type='Category', id=category_id) def stepCreateColourSizeVariatedComponent1(self,sequence=None, sequence_list=None, \ **kw): """ Create a resource with colour and size variation """ portal = self.getPortal() resource_module = portal.getDefaultModule(self.component_portal_type) resource = resource_module.newContent( portal_type=self.component_portal_type) resource.edit( title = "ColourSizeVariatedComponent1", variation_base_category_list = ['colour','size'], ) resource.setVariationCategoryList(['size/'+q for q in self.mrp_size_list] + ['colour/'+q for q in self.colour_list]) sequence.edit(component1=resource) def stepCreateColourSizeVariatedResource(self, sequence=None, sequence_list=None, \ **kw): """ Create a resource with colour and size variation """ portal = self.getPortal() resource_module = portal.getDefaultModule(self.resource_portal_type) resource = resource_module.newContent(portal_type=self.resource_portal_type) resource.edit( title = "ColourSizeVariatedResource", industrial_phase_list=["phase1", "phase2"], variation_base_category_list = ['size','colour'], ) resource.setVariationCategoryList(['size/'+q for q in self.mrp_size_list] + ['colour/'+q for q in self.colour_list]) sequence.edit( resource = resource ) resource_list = sequence.get('resource_list',default=[]) resource_list.append(resource) sequence.edit( resource_list = resource_list ) def stepCreateVariatedResource(self, sequence=None, sequence_list=None, \ **kw): """ Create a resource with variation """ portal = self.getPortal() resource_module = portal.getDefaultModule(self.resource_portal_type) resource = resource_module.newContent(portal_type=self.resource_portal_type) resource.edit( title = "VariatedResource", industrial_phase_list=["phase1", "phase2"], product_line = 'apparel' ) # resource.setSizeList(self.size_list) # Add colour variation colour_variation_count = 3 for i in range(colour_variation_count): variation = resource.newContent(portal_type = self.colour_variation_portal_type) variation.edit( title = 'ColourVariation%s' % str(i), variation_base_category_list = ('variation',) ) # Add morphology variation morphology_variation_count = 2 for i in range(morphology_variation_count) : variation = resource.newContent(portal_type=self.morphology_variation_portal_type) variation.edit( title = 'MorphologyVariation%s' % str(i), variation_base_category_list = ('variation',) ) sequence.edit( resource = resource ) resource_list = sequence.get('resource_list',default=[]) resource_list.append(resource) sequence.edit( resource_list = resource_list ) def stepClearActivities(self, sequence=None, sequence_list=None, **kw): """ Clear activity tables """ activity_tool = self.getPortal().portal_activities activity_tool.manageClearActivities(keep=0) def stepCreateProductionOrganisation1(self, sequence=None, sequence_list=None, **kw): """ Create a organisation for supply """ self.stepCreateOrganisation(sequence=sequence, sequence_list=sequence_list, title='production_organisation1', **kw) # Note: SC means Supply Chain def stepCreateGenericSC(self, sequence=None, sequence_list=None, **kw): """ Create a empty Supply Chain """ portal = self.getPortal() supply_chain_module = portal.getDefaultModule( \ portal_type=self.supply_chain_portal_type) supply_chain = supply_chain_module.newContent( \ portal_type=self.supply_chain_portal_type) supply_chain.edit( title = "Supply Chain Generic", ) sequence.edit(supply_chain=supply_chain) def stepCreateProductionSC(self, sequence=None, sequence_list=None, **kw): """ Create a empty organisation """ # Create supply chain self.stepCreateGenericSC(sequence=sequence, sequence_list=sequence_list, **kw) supply_chain = sequence.get('supply_chain') supply_chain.edit( title = 'Supply Chain Production' ) # Create production node production_organisation = sequence.get('production_organisation1') production_node = supply_chain.newContent( portal_type=self.supply_node_portal_type) production_node.edit( destination_value=production_organisation ) sequence.edit(production_node1=production_node) # Create production link production_link = supply_chain.newContent( portal_type=self.supply_link_portal_type) production_link.edit( destination_value=production_node, destination_section_value=production_organisation, min_delay=5, max_delay=6, deliverable=1, industrial_phase_list=["phase1"] ) def stepCreateComponent1(self,sequence=None, sequence_list=None, \ **kw): """ Create a resource with no variation """ portal = self.getPortal() resource_module = portal.getDefaultModule(self.component_portal_type) resource = resource_module.newContent( portal_type=self.component_portal_type) resource.edit( title = "Component1" ) sequence.edit(component1=resource) def stepCreateComponent2(self,sequence=None, sequence_list=None, \ **kw): """ Create a resource with no variation """ portal = self.getPortal() resource_module = portal.getDefaultModule(self.component_portal_type) resource = resource_module.newContent( portal_type=self.component_portal_type) resource.edit( title = "Component2" ) sequence.edit(component2=resource) def stepInvalidateTransformation(self, sequence=None, sequence_list=None, **kw): transformation = sequence.get('transformation') workflow_tool = self.getPortal().portal_workflow workflow_tool.doActionFor( transformation, 'invalidate_action' ) self.assertEquals('invalidated',transformation.getValidationState()) def stepValidateTransformation(self, sequence=None, sequence_list=None, **kw): transformation = sequence.get('transformation') workflow_tool = self.getPortal().portal_workflow workflow_tool.doActionFor( transformation, 'validate_action' ) self.assertEquals('validated',transformation.getValidationState()) def stepCreateEmptyTransformation(self, sequence=None, sequence_list=None, **kw): portal = self.getPortal() transformation_module = portal.getDefaultModule( self.transformation_portal_type) transformation = transformation_module.newContent( portal_type=self.transformation_portal_type) sequence.edit(transformation=transformation) def stepSetTransformationTransformedResourceQuantityMatrix(self, sequence=None, sequence_list=None, **kw): """ Fills variation based quantity matrix """ transformation_transformed_resource = sequence.get('transformation_transformed_resource') for colour in self.colour_list: colour_path = 'colour/%s' % colour for size in self.mrp_size_list: size_path = 'size/%s' % size quantity = self.colour_size_quantity_dict[colour][size] transformation_transformed_resource.newCell( colour_path, size_path, mapped_value_property_list = ('quantity',), quantity=quantity, membership_criterion_base_category= ('size', 'colour', ), membership_criterion_category= (size_path, colour_path,), base_id="quantity", ) def stepSetTransformationTransformedResourceVariationMatrix(self, sequence=None, sequence_list=None, **kw): """ Fills variation matrix """ transformation_transformed_resource = sequence.get('transformation_transformed_resource') for colour in self.colour_list: colour_path = 'colour/%s' % colour for size in self.mrp_size_list: size_path = 'size/%s' % size variation_list = self.colour_size_variation_dict[colour][size] transformation_transformed_resource.newCell( colour_path, size_path, categories = variation_list, membership_criterion_base_category= ('size', 'colour', ), membership_criterion_category= (size_path, colour_path,), base_id="variation", ) def stepSetOrderLineQuantityMatrix(self, sequence=None, sequence_list=None, **kw): """ Fills variation based quantity matrix """ order_line = sequence.get('order_line') for colour in self.colour_list: colour_path = 'colour/%s' % colour for size in self.mrp_size_list: size_path = 'size/%s' % size order_line.newCell( size_path, colour_path, mapped_value_property_list = ('quantity',), quantity = self.order_line_colour_size_quantity_dict[colour][size], categories = [size_path, colour_path], membership_criterion_base_category= ('size', 'colour', ), membership_criterion_category= (size_path, colour_path,), base_id='movement', ) def stepSetOrderLineVariationCategories(self, sequence=None, sequence_list=None, **kw): order_line = sequence.get('order_line') order_line.setVariationCategoryList( value = self.order_line_variation_category_list ) def stepSetTransformationTransformedResourceVariation(self, sequence=None, sequence_list=None, **kw): """ Fills categories of variation """ transformation_transformed_resource = sequence.get('transformation_transformed_resource') transformation_transformed_resource.edit( v_variation_base_category_list = self.variation_category_list, q_variation_base_category_list = self.variation_category_list, ) def stepSetTransformationVariation(self, sequence=None, sequence_list=None, **kw): """ Fills categories of variation """ transformation = sequence.get('transformation') transformation.edit( variation_base_category_list = self.variation_category_list ) def stepFillTransformationWithResource(self, sequence=None, sequence_list=None, **kw): transformation = sequence.get('transformation') resource = sequence.get('resource') self.assertNotEquals(None, resource) transformation.edit( resource_value = resource ) def stepSetOrderLineQuantity(self, sequence=None, sequence_list=None, **kw): order_line = sequence.get('order_line') order_line.edit( quantity = self.production_order_line_quantity ) def stepSetTransformationTransformedResourceQuantity(self, sequence=None, sequence_list=None, **kw): transformation_transformed_resource = sequence.get('transformation_transformed_resource') transformation_transformed_resource.edit( quantity = self.transformation_transformed_resource_quantity ) def stepSetTransformationTransformedResourceEfficiency(self, sequence=None, sequence_list=None, **kw): transformation_transformed_resource = sequence.get('transformation_transformed_resource') transformation_transformed_resource.edit( efficiency = self.transformation_transformed_resource_efficiency ) def stepSetTransformationTransformedResourceIndustrialPhaseList(self, sequence=None, sequence_list=None, **kw): transformation_transformed_resource = sequence.get('transformation_transformed_resource') transformation_transformed_resource.edit( industrial_phase_list = self.transformation_transformed_resource_industrial_phase_list ) def stepFillTransformationTransformedResourceWithComponent1(self, sequence=None, sequence_list=None, **kw): transformation_transformed_resource = sequence.get('transformation_transformed_resource') component1 = sequence.get('component1') self.assertNotEquals(None, component1) transformation_transformed_resource.edit( resource_value = component1, ) def stepCreateTransformationTransformedResource(self, sequence=None, sequence_list=None, **kw): transformation = sequence.get('transformation') transformation_transformed_resource = transformation.newContent( portal_type = self.transformed_resource_portal_type, ) sequence.edit(transformation_transformed_resource = transformation_transformed_resource) def stepCreateTransformation(self, sequence=None, sequence_list=None, **kw): """ Create a transformation """ # Create transformation portal = self.getPortal() transformation_module = portal.getDefaultModule( self.transformation_portal_type) transformation = transformation_module.newContent( portal_type=self.transformation_portal_type) sequence.edit(transformation=transformation) # Set resource resource = sequence.get('resource') transformation.setResourceValue(resource) # Create operation line 1 operation_line = transformation.newContent( portal_type=self.operation_line_portal_type) operation_line.edit( # FIXME hardcoded quantity=2, resource_value=portal.portal_categories.resolveCategory( 'operation/operation1'), industrial_phase_list=['phase1'] ) # Create operation line 2 operation_line = transformation.newContent( portal_type=self.operation_line_portal_type) operation_line.edit( # FIXME hardcoded quantity=3, resource_value=portal.portal_categories.resolveCategory( 'operation/operation2'), industrial_phase_list=['phase2'] ) # Create transformed resource line 1 line = transformation.newContent( portal_type=self.transformed_resource_portal_type) line.edit( # FIXME hardcoded quantity=6, resource_value=sequence.get('component1'), industrial_phase_list=['supply_phase1'] ) # Create transformed resource line 2 line = transformation.newContent( portal_type=self.transformed_resource_portal_type) line.edit( # FIXME hardcoded quantity=7, resource_value=sequence.get('component2'), industrial_phase_list=['supply_phase2'] ) def stepCreateOrder(self, sequence=None, sequence_list=None, **kw): """ Create a filled order """ portal = self.getPortal() order_module = portal.getDefaultModule(portal_type=self.order_portal_type) order = order_module.newContent(portal_type=self.order_portal_type) organisation = sequence.get('organisation') supply_chain = sequence.get('supply_chain') order.edit( start_date = self.datetime + 10, stop_date = self.datetime + 20, destination_value=organisation, destination_section_value=organisation, specialise_value=supply_chain ) sequence.edit(order=order) def stepCreateOrderLine(self, sequence=None, sequence_list=None, **kw): """ Create a filled order line """ order = sequence.get('order') order_line = order.newContent(portal_type=self.order_line_portal_type) resource = sequence.get('resource') transformation = sequence.get('transformation') order_line.edit( resource_value=resource, specialise_value=transformation, quantity=5 ) sequence.edit(order_line=order_line) def stepCreateOrderLineWithoutTransformation(self, sequence=None, sequence_list=None, **kw): """ Create a empty order line """ order = sequence.get('order') order_line = order.newContent(portal_type=self.order_line_portal_type) resource = sequence.get('resource') order_line.edit( resource_value=resource, quantity=5 ) sequence.edit(order_line=order_line) def stepCheckVariationSimulation(self, sequence=None, sequence_list=None, **kw): # XXX: This check is not testing too much, beside for variation system # used in production simulations. order = sequence.get('order') movement_list = order.getMovementList() self.assertNotEqual(len(movement_list), 0) for order_movement in movement_list: size = order_movement.getSize() colour = order_movement.getColour() self.assertNotEqual(size, None) self.assertNotEqual(colour, None) want_produced_quantity = self.order_line_colour_size_quantity_dict[colour][size] want_consume_quantity = self.colour_size_quantity_dict[colour][size] want_consume_for_production = want_produced_quantity * want_consume_quantity produced_movement = order_movement.getOrderRelatedValue(\ portal_type='Simulation Movement') self.assertEquals( want_produced_quantity, produced_movement.getQuantity() ) transformation_rule = produced_movement.contentValues()[0] consumption_movement = [q for q in transformation_rule.contentValues() \ if q.getId().startswith('cr')][0] production_delivery_movement = [q for q in transformation_rule.contentValues() \ if q.getId().startswith('pr')][0] self.assertEquals( want_consume_for_production, consumption_movement.getQuantity() ) self.assertEquals( want_produced_quantity, production_delivery_movement.getQuantity() ) transformation_sourcing_rule = consumption_movement.contentValues()[0] consume_delivery_movement = transformation_sourcing_rule.contentValues()[0] self.assertEquals( want_consume_for_production, consume_delivery_movement.getQuantity() ) def stepCheckEfficiencySimulation(self, sequence=None, sequence_list=None, **kw): """Check that efficiency is applied where is it needed""" # XXX: This check is not testing too much, beside for efficiency related quantity # in just two places. order = sequence.get('order') applied_rule = order.getCausalityRelatedValue(portal_type = self.applied_rule_portal_type) production_movement_list = applied_rule.contentValues() # XXX: hardcode self.assertEquals( 1, len(production_movement_list) ) production_movement = production_movement_list[0] transformation_applied_rule = production_movement.contentValues()[0] consumed_movement = [q for q in transformation_applied_rule.contentValues() \ if q.getId().startswith('cr')][0] self.assertEquals( consumed_movement.getQuantity(), self.quantity_after_efficiency_calculation ) transformation_sourcing_rule = consumed_movement.contentValues()[0] consumption_delivery_movement = [q for q in transformation_sourcing_rule.contentValues() \ if q.getId().startswith('ts')][0] self.assertEquals( consumption_delivery_movement.getQuantity(), self.quantity_after_efficiency_calculation ) def stepCheckOrderLineTransformationIsSet(self, sequence=None, sequence_list=None, **kw): order_line = sequence.get('order_line') transformation = sequence.get('transformation') self.assertNotEquals(None, transformation) self.assertEquals(order_line.getSpecialiseValue(), transformation) def stepCheckOrderLineTransformationIsNotSet(self, sequence=None, sequence_list=None, **kw): order_line = sequence.get('order_line') self.assertEquals(order_line.getSpecialiseValue(), None) def stepRemoveResourceFromOrderLine(self, sequence=None, sequence_list=None, **kw): order_line = sequence.get('order_line') order_line.edit( resource = None ) def stepCheckOrderSimulation(self, sequence=None, sequence_list=None, **kw): """ Test if simulation is matching order """ order = sequence.get('order') related_applied_rule_list = order.getCausalityRelatedValueList( \ portal_type=self.applied_rule_portal_type) no_applied_rule_state = ('draft', 'auto_planned') order_state = order.getSimulationState() if order_state in no_applied_rule_state: self.assertEquals(0, len(related_applied_rule_list)) else: self.assertEquals(1, len(related_applied_rule_list)) applied_rule = related_applied_rule_list[0].getObject() sequence.edit(applied_rule=applied_rule) self.failUnless(applied_rule is not None) self.failUnless(order_state, \ applied_rule.getLastExpandSimulationState()) # Test if applied rule has a specialise value with default_order_rule portal_rules = getToolByName(order, 'portal_rules') # XXX hardcoded value self.assertEquals('default_production_order_rule', \ applied_rule.getSpecialiseReference()) simulation_movement_list = applied_rule.objectValues() sequence.edit(simulation_movement_list=simulation_movement_list) def checkObjectAttributes(self, object, attribute_list): LOG('checkObjectAttributes object.getPath',0,object.getPath()) for value, attribute in attribute_list: try: self.assertEquals(value, getattr(object, attribute)()) except AssertionError: LOG('Raise Assertion error',0,'') LOG('object.getQuantity()',0,object.getQuantity()) LOG('object.__dict__',0,object.__dict__) order_value = object.getOrderValue() LOG('object.getOrderValue()',0, order_value) if order_value is not None: LOG('object.getOrderValue().getQuantity()',0,order_value.getQuantity()) raise AssertionError, "Attribute: %s, Value: %s, Result: %s" %\ (attribute, value, getattr(object, attribute)()) def stepCheckProductionSimulation(self, sequence=None, sequence_list=None, **kw): """ Hardcoded check """ self.stepCheckOrderSimulation(sequence=sequence, sequence_list=sequence_list, **kw) # Test simulation movement generated related to order line simulation_movement_list = sequence.get('simulation_movement_list') self.assertEquals(1, len(simulation_movement_list)) order_line = sequence.get('order_line') related_simulation_movement_list = order_line.getOrderRelatedValueList() self.assertEquals(1, len(related_simulation_movement_list)) related_simulation_movement = related_simulation_movement_list[0] self.assertEquals(related_simulation_movement, simulation_movement_list[0]) production_organisation1 = sequence.get('production_organisation1') # XXX FIXME test date self.checkObjectAttributes( related_simulation_movement, ( (order_line.getQuantity(), 'getQuantity'), (order_line.getResourceValue(), 'getResourceValue'), (order_line.getVariationCategoryList(), 'getVariationCategoryList'), (order_line.getDestinationValue(), 'getDestinationValue'), (order_line.getDestinationSectionValue(), 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) # Test next applied rule applied_rule_list = related_simulation_movement.objectValues() self.assertEquals(1, len(applied_rule_list)) applied_rule = applied_rule_list[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_rule', \ applied_rule.getSpecialiseReference()) # Test deeper simulation simulation_movement_list = applied_rule.objectValues() self.assertEquals(2, len(simulation_movement_list)) # Test consumed movement transformation = sequence.get('transformation') consumed_movement_id = 'cr_%s_1_%s' % (transformation.getId(), applied_rule.getParentId()) consumed_movement = applied_rule[consumed_movement_id] operation_resource = consumed_movement.portal_categories.resolveCategory( 'operation/operation1') # FIXME self.checkObjectAttributes( consumed_movement, ( (10, 'getQuantity'), (operation_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) # Test produced resource produced_movement = applied_rule.pr resource = sequence.get('resource') production_organisation1 = sequence.get('production_organisation1') self.checkObjectAttributes( produced_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), (production_organisation1, 'getDestinationSectionValue'), (None, 'getSourceValue'), (None, 'getSourceSectionValue'))) def stepCreateSupplyOrganisation1(self, sequence=None, sequence_list=None, **kw): """ Create a organisation for supply """ self.stepCreateOrganisation(sequence=sequence, sequence_list=sequence_list, title='supply_organisation1', **kw) def stepCreateSourcingSC(self, sequence=None, sequence_list=None, **kw): """ Create a empty organisation """ # Create supply chain self.stepCreateProductionSC(sequence=sequence, sequence_list=sequence_list, **kw) supply_chain = sequence.get('supply_chain') supply_chain.edit( title = 'Supply Chain Sourcing', ) # Create supply node supply_organisation = sequence.get('supply_organisation1') supply_node = supply_chain.newContent( portal_type=self.supply_node_portal_type) supply_node.edit( destination_value=supply_organisation ) # Create sourcing link supply_link = supply_chain.newContent( portal_type=self.supply_link_portal_type) production_node1 = sequence.get('production_node1') production_organisation1 = sequence.get('production_organisation1') supply_link.edit( source_value=supply_node, source_section_value=supply_organisation, destination_value=production_node1, destination_section_value=production_organisation1, min_delay=5, max_delay=6, deliverable=0, industrial_phase_list=["supply_phase1"] ) def stepCheckSourcingSimulation(self, sequence=None, sequence_list=None, **kw): """ Hardcoded check """ self.stepCheckOrderSimulation(sequence=sequence, sequence_list=sequence_list, **kw) # Test simulation movement generated related to order line simulation_movement_list = sequence.get('simulation_movement_list') self.assertEquals(1, len(simulation_movement_list)) order_line = sequence.get('order_line') related_simulation_movement_list = order_line.getOrderRelatedValueList() self.assertEquals(1, len(related_simulation_movement_list)) related_simulation_movement = related_simulation_movement_list[0] self.assertEquals(related_simulation_movement, simulation_movement_list[0]) production_organisation1 = sequence.get('production_organisation1') # XXX FIXME test date self.checkObjectAttributes( related_simulation_movement, ( (order_line.getQuantity(), 'getQuantity'), (order_line.getResourceValue(), 'getResourceValue'), (order_line.getVariationCategoryList(), 'getVariationCategoryList'), (order_line.getDestinationValue(), 'getDestinationValue'), (order_line.getDestinationSectionValue(), 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) # Test next applied rule applied_rule_list = related_simulation_movement.objectValues() self.assertEquals(1, len(applied_rule_list)) applied_rule = applied_rule_list[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_rule', \ applied_rule.getSpecialiseReference()) # Test deeper simulation simulation_movement_list = list(applied_rule.objectValues()) # FIXME self.assertEquals(3, len(simulation_movement_list)) # Test produced resource produced_movement = applied_rule.pr resource = sequence.get('resource') production_organisation1 = sequence.get('production_organisation1') self.checkObjectAttributes( produced_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), (production_organisation1, 'getDestinationSectionValue'), (None, 'getSourceValue'), (None, 'getSourceSectionValue'))) self.assertEquals(0, len(produced_movement.objectValues())) simulation_movement_list.remove(produced_movement) # All code before is a stupid copy (except movement count) # Test consumed movement operation_resource = resource.portal_categories.resolveCategory( 'operation/operation1') component_resource = sequence.get('component1') # for consumed_movement in (applied_rule.cr_1, applied_rule.cr_2): for consumed_movement in simulation_movement_list: if consumed_movement.getResourceValue() == operation_resource: operation_movement = consumed_movement else: component_movement = consumed_movement # Check operation movement self.checkObjectAttributes( operation_movement, ( (10, 'getQuantity'), (operation_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) self.assertEquals(0, len(operation_movement.objectValues())) # Check component movement self.checkObjectAttributes( component_movement, ( (30, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) self.assertEquals(1, len(component_movement.objectValues())) # Test supply applied rule applied_rule = component_movement.objectValues()[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_sourcing_rule', \ applied_rule.getSpecialiseReference()) # Test supply movement simulation_movement_list = applied_rule.objectValues() # FIXME self.assertEquals(1, len(simulation_movement_list)) # Test supply resource supply_movement = applied_rule.ts supply_organisation1 = sequence.get('supply_organisation1') self.checkObjectAttributes( supply_movement, ( (30, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), (production_organisation1, 'getDestinationSectionValue'), (supply_organisation1, 'getSourceValue'), (supply_organisation1, 'getSourceSectionValue'))) self.assertEquals(0, len(supply_movement.objectValues())) sequence.edit( produced_movement = produced_movement, operation_movement = operation_movement, component_movement = component_movement, supply_movement = supply_movement, produced_delivery_movement = related_simulation_movement, ) def stepCreateProductionOrganisation2(self, sequence=None, sequence_list=None, **kw): """ Create a organisation for supply """ self.stepCreateOrganisation(sequence=sequence, sequence_list=sequence_list, title='production_organisation2', **kw) def stepCreateSupplyOrganisation2(self, sequence=None, sequence_list=None, **kw): """ Create a organisation for supply """ self.stepCreateOrganisation(sequence=sequence, sequence_list=sequence_list, title='supply_organisation2', **kw) def stepCreateTwoPhasesSC(self, sequence=None, sequence_list=None, **kw): """ Create a empty organisation """ # Create supply chain self.stepCreateSourcingSC(sequence=sequence, sequence_list=sequence_list, **kw) supply_chain = sequence.get('supply_chain') supply_chain.edit( title = 'Supply Chain Two Phases', ) # Create production node production_organisation2 = sequence.get('production_organisation2') production_node2 = supply_chain.newContent( portal_type=self.supply_node_portal_type) production_node2.edit( destination_value=production_organisation2 ) sequence.edit(production_node2=production_node2) # Create production link production_link2 = supply_chain.newContent( portal_type=self.supply_link_portal_type) production_link2.edit( destination_value=production_node2, min_delay=5, max_delay=6, deliverable=0, industrial_phase_list=["phase2"] ) # Link production_node2 and production_node1 supply_link = supply_chain.newContent( portal_type=self.supply_link_portal_type) production_node1 = sequence.get('production_node1') supply_link.edit( source_value=production_node2, destination_value=production_node1, min_delay=5, max_delay=6, deliverable=0, industrial_phase_list=[] ) # Create supply node supply_organisation2 = sequence.get('supply_organisation2') supply_node2 = supply_chain.newContent( portal_type=self.supply_node_portal_type) supply_node2.edit( destination_value=supply_organisation2 ) # Create sourcing link supply_link2 = supply_chain.newContent( portal_type=self.supply_link_portal_type) supply_link2.edit( source_value=supply_node2, destination_value=production_node2, min_delay=5, max_delay=6, deliverable=0, industrial_phase_list=["supply_phase2"] ) def stepCheckTwoPhasesSimulation(self, sequence=None, sequence_list=None, **kw): """ Hardcoded check """ # self.stepCheckSourcingSimulation(sequence=sequence, # sequence_list=sequence_list, **kw) self.stepCheckOrderSimulation(sequence=sequence, sequence_list=sequence_list, **kw) # Test simulation movement generated related to order line simulation_movement_list = sequence.get('simulation_movement_list') self.assertEquals(1, len(simulation_movement_list)) order_line = sequence.get('order_line') related_simulation_movement_list = order_line.getOrderRelatedValueList() self.assertEquals(1, len(related_simulation_movement_list)) related_simulation_movement = related_simulation_movement_list[0] self.assertEquals(related_simulation_movement, simulation_movement_list[0]) production_organisation1 = sequence.get('production_organisation1') # XXX FIXME test date self.checkObjectAttributes( related_simulation_movement, ( (order_line.getQuantity(), 'getQuantity'), (order_line.getResourceValue(), 'getResourceValue'), (order_line.getVariationCategoryList(), 'getVariationCategoryList'), (order_line.getDestinationValue(), 'getDestinationValue'), (order_line.getDestinationSectionValue(), 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) # Test next applied rule applied_rule_list = related_simulation_movement.objectValues() self.assertEquals(1, len(applied_rule_list)) applied_rule = applied_rule_list[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_rule', \ applied_rule.getSpecialiseReference()) # Test deeper simulation simulation_movement_list = list(applied_rule.objectValues()) # FIXME self.assertEquals(4, len(simulation_movement_list)) # Test produced resource produced_movement = applied_rule.pr resource = sequence.get('resource') production_organisation1 = sequence.get('production_organisation1') self.checkObjectAttributes( produced_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), (production_organisation1, 'getDestinationSectionValue'), (None, 'getSourceValue'), (None, 'getSourceSectionValue'))) self.assertEquals(0, len(produced_movement.objectValues())) # Get modified resource (test later) modified_movement = applied_rule.mr_1 simulation_movement_list.remove(produced_movement) simulation_movement_list.remove(modified_movement) # All code before is a stupid copy (except movement count) # Test consumed movement operation_resource = resource.portal_categories.resolveCategory( 'operation/operation1') component_resource = sequence.get('component1') # for consumed_movement in (applied_rule.cr_1, applied_rule.cr_2): for consumed_movement in simulation_movement_list: if consumed_movement.getResourceValue() == operation_resource: operation_movement = consumed_movement else: component_movement = consumed_movement # Check operation movement self.checkObjectAttributes( operation_movement, ( (10, 'getQuantity'), (operation_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) self.assertEquals(0, len(operation_movement.objectValues())) # Check component movement self.checkObjectAttributes( component_movement, ( (30, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'))) self.assertEquals(1, len(component_movement.objectValues())) # Test supply applied rule applied_rule = component_movement.objectValues()[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_sourcing_rule', \ applied_rule.getSpecialiseReference()) # Test supply movement simulation_movement_list = applied_rule.objectValues() # FIXME self.assertEquals(1, len(simulation_movement_list)) # Test supply resource supply_movement = applied_rule.ts supply_organisation1 = sequence.get('supply_organisation1') self.checkObjectAttributes( supply_movement, ( (30, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), (production_organisation1, 'getDestinationSectionValue'), (supply_organisation1, 'getSourceValue'), (supply_organisation1, 'getSourceSectionValue'))) self.assertEquals(0, len(supply_movement.objectValues())) # Test modified movement resource = sequence.get('resource') production_organisation1 = sequence.get('production_organisation1') self.checkObjectAttributes( modified_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), (['industrial_phase/phase2'], 'getVariationCategoryList'), (production_organisation1, 'getSourceValue'), (production_organisation1, 'getSourceSectionValue'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'))) self.assertEquals(1, len(modified_movement.objectValues())) # Test next applied rule applied_rule_list = modified_movement.objectValues() applied_rule = applied_rule_list[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_sourcing_rule', \ applied_rule.getSpecialiseReference()) # Test deeper simulation simulation_movement_list = list(applied_rule.objectValues()) self.assertEquals(1, len(simulation_movement_list)) # Test produced resource sourcing_movement = simulation_movement_list[0] resource = sequence.get('resource') production_organisation1 = sequence.get('production_organisation1') production_organisation2 = sequence.get('production_organisation2') self.checkObjectAttributes( sourcing_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), (['industrial_phase/phase2'], 'getVariationCategoryList'), (production_organisation1, 'getDestinationValue'), # XXX (production_organisation1, 'getDestinationSectionValue'), (production_organisation2, 'getSourceValue'), # XXX (production_organisation2, 'getSourceSectionValue'))) )) self.assertEquals(1, len(sourcing_movement.objectValues())) # Test next applied rule applied_rule_list = sourcing_movement.objectValues() self.assertEquals(1, len(applied_rule_list)) applied_rule = applied_rule_list[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_rule', \ applied_rule.getSpecialiseReference()) # Test deeper simulation simulation_movement_list = list(applied_rule.objectValues()) # FIXME self.assertEquals(3, len(simulation_movement_list)) # Test produced resource produced_movement = applied_rule.pr resource = sequence.get('resource') production_organisation2 = sequence.get('production_organisation2') self.checkObjectAttributes( produced_movement, ( (5, 'getQuantity'), (resource, 'getResourceValue'), (['industrial_phase/phase2'], 'getVariationCategoryList'), (production_organisation2, 'getDestinationValue'), # XXX (production_organisation2, 'getDestinationSectionValue'), (None, 'getSourceValue'), (None, 'getSourceSectionValue'))) self.assertEquals(0, len(produced_movement.objectValues())) simulation_movement_list.remove(produced_movement) # All code before is a stupid copy (except movement count) # Test consumed movement operation_resource = resource.portal_categories.resolveCategory( 'operation/operation2') component_resource = sequence.get('component2') for consumed_movement in simulation_movement_list: if consumed_movement.getResourceValue() == operation_resource: operation_movement = consumed_movement else: component_movement = consumed_movement # Check operation movement self.checkObjectAttributes( operation_movement, ( (15, 'getQuantity'), (operation_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation2, 'getSourceValue'), # XXX (production_organisation2, 'getSourceSectionValue'))) )) self.assertEquals(0, len(operation_movement.objectValues())) # Check component movement self.checkObjectAttributes( component_movement, ( (35, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (None, 'getDestinationValue'), (None, 'getDestinationSectionValue'), (production_organisation2, 'getSourceValue'), # XXX (production_organisation2, 'getSourceSectionValue'))) )) self.assertEquals(1, len(component_movement.objectValues())) # Test supply applied rule applied_rule = component_movement.objectValues()[0] self.assertEquals("Applied Rule", applied_rule.getPortalType()) portal_rules = getToolByName(applied_rule, 'portal_rules') self.assertEquals('default_transformation_sourcing_rule', \ applied_rule.getSpecialiseReference()) # Test supply movement simulation_movement_list = applied_rule.objectValues() # FIXME self.assertEquals(1, len(simulation_movement_list)) # Test supply resource supply_movement = applied_rule.ts supply_organisation2 = sequence.get('supply_organisation2') self.checkObjectAttributes( supply_movement, ( (35, 'getQuantity'), (component_resource, 'getResourceValue'), ([], 'getVariationCategoryList'), (production_organisation2, 'getDestinationValue'), # XXX (production_organisation2, 'getDestinationSectionValue'), (supply_organisation2, 'getSourceValue'), # XXX (supply_organisation2, 'getSourceSectionValue'))) )) self.assertEquals(0, len(supply_movement.objectValues())) SOURCING_ORDER_SEQUENCE = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateSupplyOrganisation1 \ CreateSourcingSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ CheckSourcingSimulation \ ConfirmOrder \ Tic \ CheckSourcingSimulation \ ' class TestProductionOrder(TestProductionOrderMixin, ERP5TypeTestCase): """ Test business template erp5_mrp """ run_all_test = 1 def getTitle(self): return "Production Order" def test_01_testProductionSimulationExpand(self, quiet=0, run=run_all_test): """ Test generation and update of order applied rule. """ if not run: return sequence_list = SequenceList() # Test when order is sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ CheckProductionSimulation \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_02_testSourcingSimulationExpand(self, quiet=0, run=run_all_test): """ Test generation and update of order applied rule. """ if not run: return sequence_list = SequenceList() # Test when order is sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateSupplyOrganisation1 \ CreateSourcingSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ CheckSourcingSimulation \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_03_testIndustrialPhase(self, quiet=0, run=run_all_test): """ """ if not run: return sequence_list = SequenceList() # Test when order is sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionOrganisation2 \ CreateSupplyOrganisation1 \ CreateSupplyOrganisation2 \ CreateTwoPhasesSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateComponent2 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ CheckTwoPhasesSimulation \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_04_testProductionSimulationBuild(self, quiet=0, run=run_all_test): """ Test delivery building. XXX Test method still required """ if not run: return sequence_list = SequenceList() # Test when order is sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ ConfirmOrder \ Tic \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_05_testSourcingSimulationBuild(self, quiet=0, run=run_all_test): """ Test delivery building. XXX Test method still required """ if not run: return sequence_list = SequenceList() # Test when order is sequence_list.addSequenceString(self.SOURCING_ORDER_SEQUENCE) sequence_list.play(self) def test_06_testIndustrialPhase(self, quiet=0, run=run_all_test): """ Test delivery building. XXX Test method still required """ if not run: return sequence_list = SequenceList() # Test when order is sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionOrganisation2 \ CreateSupplyOrganisation1 \ CreateSupplyOrganisation2 \ CreateTwoPhasesSC \ CreateNotVariatedResource \ CreateComponent1 \ CreateComponent2 \ CreateTransformation \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ Tic \ OrderOrder \ Tic \ ConfirmOrder \ Tic \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def stepCopyPasteSupplyChain(self, sequence=None, sequence_list=None, **kw): """ Copy/Paste the supply chain """ portal = self.getPortal() supply_chain_module = portal.getDefaultModule( \ portal_type=self.supply_chain_portal_type) supply_chain = sequence.get('supply_chain') cb_data = supply_chain_module.manage_copyObjects([supply_chain.getId()]) copied, = supply_chain_module.manage_pasteObjects(cb_data) pasted_sc = supply_chain_module[copied['new_id']] sequence.edit(pasted_sc=pasted_sc) def stepCheckPastedSupplyChain(self, sequence=None, sequence_list=None, **kw): """ Check pasted supply chain """ pasted_sc = sequence.get('pasted_sc') pasted_supply_node = pasted_sc.contentValues(portal_type='Supply Node')[0] pasted_supply_link = pasted_sc.contentValues(portal_type='Supply Link')[0] self.assertEquals(pasted_supply_node.getRelativeUrl(), pasted_supply_link.getDestination()) def test_07_testTransformationInteractionProductionOrderLine(self, quiet=0, run=run_all_test): """ Test for setting/resetting Transformation on Production Order Line """ if not run: return bootstrap_sequence_string = '\ ClearActivities \ CreateNotVariatedResource \ CreateOrder \ ' sequence_list = SequenceList() # normal case sequence_string = bootstrap_sequence_string + '\ CreateTransformation \ Tic \ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsSet \ ' sequence_list.addSequenceString(sequence_string) # no transformation sequence_string = bootstrap_sequence_string + '\ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsNotSet \ ' sequence_list.addSequenceString(sequence_string) # transformation set, then not modified sequence_string = bootstrap_sequence_string + '\ CreateTransformation \ Tic \ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsSet \ RemoveResourceFromOrderLine \ Tic \ CheckOrderLineTransformationIsSet \ ' sequence_list.addSequenceString(sequence_string) # more than one transformation sequence_string = bootstrap_sequence_string + '\ CreateTransformation \ CreateTransformation \ Tic \ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsNotSet \ ' sequence_list.addSequenceString(sequence_string) # case of invalidated Transformation sequence_string = bootstrap_sequence_string + '\ CreateTransformation \ Tic \ ValidateTransformation \ InvalidateTransformation \ Tic \ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsNotSet \ ' sequence_list.addSequenceString(sequence_string) # case of invalidated Transformation and other sequence_string = bootstrap_sequence_string + '\ CreateTransformation \ Tic \ ValidateTransformation \ InvalidateTransformation \ Tic \ CreateTransformation \ Tic \ CreateOrderLineWithoutTransformation \ Tic \ CheckOrderLineTransformationIsSet \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_08_testTransformationWithEfficiency(self, quiet=0, run=run_all_test): """ Test, that efficiency from transformation applies correctly """ if not run: return sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateSupplyOrganisation1 \ CreateSourcingSC \ Tic \ CreateNotVariatedResource \ CreateComponent1 \ CreateEmptyTransformation \ FillTransformationWithResource \ Tic \ CreateTransformationTransformedResource \ FillTransformationTransformedResourceWithComponent1 \ SetTransformationTransformedResourceQuantity \ SetTransformationTransformedResourceEfficiency \ SetTransformationTransformedResourceIndustrialPhaseList \ Tic \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ SetOrderLineQuantity \ Tic \ OrderOrder \ Tic \ CheckEfficiencySimulation \ ' sequence_list = SequenceList() sequence_list.addSequenceString(sequence_string) # case - we need Q:10.0, efficiency is 80% (we need more), producing 1.0 self.transformation_transformed_resource_quantity = 10.0 self.transformation_transformed_resource_efficiency = 0.8 # 80% self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 1.0 self.quantity_after_efficiency_calculation = 12.5 # (1.0 * 10.0) / 0.8 sequence_list.play(self) # case - we need Q:10.0, efficiency is None (normal, nothing set), producing 1.0 self.transformation_transformed_resource_quantity = 10.0 self.transformation_transformed_resource_efficiency = None self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 1.0 self.quantity_after_efficiency_calculation = 10.0 # (1.0 * 10.0) / 1.0 sequence_list.play(self) # case - we need Q:10.0, efficiency is 100% (normal), producing 1.0 self.transformation_transformed_resource_quantity = 10.0 self.transformation_transformed_resource_efficiency = 1.0 self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 1.0 self.quantity_after_efficiency_calculation = 10.0 # (1.0 * 10.0) / 1.0 sequence_list.play(self) # case - we need Q:10.0, efficiency is 125% (miracle?), producing 1.0 self.transformation_transformed_resource_quantity = 10.0 self.transformation_transformed_resource_efficiency = 1.25 self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 1.0 self.quantity_after_efficiency_calculation = 8.0 # (1.0 * 10.0) / 1.25 sequence_list.play(self) # case - we need Q:10.0, efficiency is -80% (nonsense?), producing 1.0 self.transformation_transformed_resource_quantity = 10.0 self.transformation_transformed_resource_efficiency = -0.8 self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 1.0 self.quantity_after_efficiency_calculation = -12.5 # (1.0 * 10.0) / -0.8 sequence_list.play(self) def test_09_testTransformationWithVariation(self, quiet=0, run=run_all_test): """ Test, that variation from transformation works correctly on order Note: Read below variables to know, what and how was defined """ if not run: return self.transformation_transformed_resource_quantity = 0.0 self.transformation_transformed_resource_industrial_phase_list = ['supply_phase1',] self.production_order_line_quantity = 0.0 self.variation_category_list = ['colour','size'] self.colour_size_quantity_dict = { 'green' : { 'Man' : 1.0, 'Woman' : 2.0 }, 'blue' : { 'Man' : 3.0, 'Woman' : 4.0 }, } self.colour_size_variation_dict = { 'green' : { 'Man' : ('colour/green','size/Man'), 'Woman' : ('colour/green','size/Woman') }, 'blue' : { 'Man' : ('colour/blue','size/Man'), 'Woman' : ('colour/blue','size/Woman') }, } self.order_line_variation_category_list = [ 'size/Man', 'size/Woman', 'colour/green', 'colour/blue', ] self.order_line_colour_size_quantity_dict = { 'green' : { 'Man' : 9.0, 'Woman' : 8.0 }, 'blue' : { 'Man' : 7.0, 'Woman' : 6.0 }, } sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateSupplyOrganisation1 \ CreateSourcingSC \ Tic \ CreateColourSizeVariatedResource \ CreateColourSizeVariatedComponent1 \ Tic \ CreateEmptyTransformation \ FillTransformationWithResource \ SetTransformationVariation \ Tic \ CreateTransformationTransformedResource \ FillTransformationTransformedResourceWithComponent1 \ SetTransformationTransformedResourceVariation \ SetTransformationTransformedResourceIndustrialPhaseList \ Tic \ SetTransformationTransformedResourceQuantityMatrix \ SetTransformationTransformedResourceVariationMatrix \ Tic \ CreateOrganisation \ CreateOrder \ CreateOrderLine \ SetOrderLineVariationCategories \ SetOrderLineQuantityMatrix \ Tic \ OrderOrder \ Tic \ CheckVariationSimulation \ ConfirmOrder \ Tic \ ' sequence_list = SequenceList() sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_50_testCopyPaste(self, quiet=0, run=run_all_test): """ Check that relation are changed when doing a copy/paste, on supply chain """ if not run: return sequence_list = SequenceList() sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionSC \ CopyPasteSupplyChain \ Tic \ CheckPastedSupplyChain \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def stepCreateEmptySC(self, sequence=None, sequence_list=None, **kw): """ Create a empty Supply Chain """ portal = self.getPortal() supply_chain_module = portal.getDefaultModule( \ portal_type=self.supply_chain_portal_type) supply_chain = supply_chain_module.newContent( \ portal_type=self.supply_chain_portal_type) supply_chain.edit( title = "Supply Chain Empty", ) sequence.edit(empty_supply_chain=supply_chain) def stepCutPasteSupplyNodeInAnotherContainer(self, sequence=None, sequence_list=None, **kw): """ Cut/Paste a supply node in another container """ supply_chain = sequence.get('supply_chain') empty_supply_chain = sequence.get('empty_supply_chain') supply_node = supply_chain.contentValues(portal_type='Supply Node')[0] cb_data = supply_chain.manage_cutObjects([supply_node.getId()]) copied, = empty_supply_chain.manage_pasteObjects(cb_data) def stepCheckPastedSupplyNode(self, sequence=None, sequence_list=None, **kw): """ Check pasted supply node """ supply_chain = sequence.get('supply_chain') empty_supply_chain = sequence.get('empty_supply_chain') supply_node = empty_supply_chain.contentValues(portal_type='Supply Node')[0] supply_link = supply_chain.contentValues(portal_type='Supply Link')[0] self.assertEquals(supply_node.getRelativeUrl(), supply_link.getDestination()) def test_51_testCutPasteInAnotherContainer(self, quiet=0, run=run_all_test): """ Check that relations are changed when doing a copy/paste, on a supply chain. The point in this test is that internal relations should be updated when copying an object. Suppose that a document D1 contains sub-objects S1_1 and S1_2, and S1_1 is related to S1_2. When copying D1 to D2, S2_1 and S2_2 are also copied from S1_1 and S1_2. Now S2_1 should be related to S2_2, instead of S1_2. Good: D1 -+- S1_1 D1 -+- S1_1 D2 -+- S2_1 | | => | | | | | v | v | v +- S1_2 +- S1_2 +- S2_2 Bad: D1 -+- S1_1 D1 -+- S1_1 D2 -+- S2_1 | | => | | __|_/ | v | v / | +- S1_2 +- S1_2<--/ +- S2_2 """ if not run: return sequence_list = SequenceList() sequence_string = '\ ClearActivities \ CreateProductionOrganisation1 \ CreateProductionSC \ CreateEmptySC \ Tic \ CutPasteSupplyNodeInAnotherContainer \ Tic \ CheckPastedSupplyNode \ ' sequence_list.addSequenceString(sequence_string) sequence_list.play(self) def test_suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(TestProductionOrder)) return suite