From b3ee2ba4d5916f032e33ba34abff48050971b225 Mon Sep 17 00:00:00 2001 From: Kazuhiko Shiozaki <kazuhiko@nexedi.com> Date: Mon, 15 Feb 2010 06:39:04 +0000 Subject: [PATCH] add tests that checks legacy behaviour (i.e. using 'order' category in top level simulation movements.) git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@32533 20353a03-c40f-0410-a6d1-a30d3c3de9de --- .../ERP5/tests/testLegacyProductionOrder.py | 1846 +++++++++++++++++ .../tests/testLegacyProductionPackingList.py | 781 +++++++ 2 files changed, 2627 insertions(+) create mode 100644 product/ERP5/tests/testLegacyProductionOrder.py create mode 100644 product/ERP5/tests/testLegacyProductionPackingList.py diff --git a/product/ERP5/tests/testLegacyProductionOrder.py b/product/ERP5/tests/testLegacyProductionOrder.py new file mode 100644 index 0000000000..8ffea6525f --- /dev/null +++ b/product/ERP5/tests/testLegacyProductionOrder.py @@ -0,0 +1,1846 @@ +############################################################################## +# +# 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',) + + 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') + colour_count = size_count = 0 + + for colour in self.colour_list: + for size in self.mrp_size_list: + id = 'quantity_%s_%s'%(colour_count,size_count) + transformation_transformed_resource.newContent( + portal_type = 'Mapped Value', + id = id, + mapped_value_property_list = ('quantity',), + membership_criterion_base_category = ('colour', 'size'), + membership_criterion_category = ('colour/%s'%(colour,), 'size/%s'%(size,)), + quantity = self.colour_size_quantity_dict[colour][size], + ) + size_count +=1 + size_count = 0 + colour_count +=1 + + def stepSetTransformationTransformedResourceVariationMatrix(self, sequence=None, sequence_list=None, + **kw): + """ + Fills variation matrix + """ + + transformation_transformed_resource = sequence.get('transformation_transformed_resource') + colour_count = size_count = 0 + + for colour in self.colour_list: + for size in self.mrp_size_list: + id = 'variation_%s_%s'%(colour_count,size_count) + transformation_transformed_resource.newContent( + portal_type = 'Mapped Value', + id = id, + mapped_value_property_list = (), + membership_criterion_base_category = ('colour', 'size'), + membership_criterion_category = ('colour/%s'%(colour,), 'size/%s'%(size,)), + categories = self.colour_size_variation_dict[colour][size], + ) + size_count +=1 + size_count = 0 + colour_count +=1 + + def stepSetOrderLineQuantityMatrix(self, sequence=None, sequence_list=None, + **kw): + """ + Fills variation based quantity matrix + """ + order_line = sequence.get('order_line') + colour_count = size_count = 0 + + for colour in self.colour_list: + for size in self.mrp_size_list: + id = 'movement_%s_%s'%(colour_count,size_count) + order_line.newContent( + portal_type = self.order_cell_portal_type, + id = id, + mapped_value_property_list = ('quantity', 'price'), + membership_criterion_base_category = ('colour', 'size'), + membership_criterion_category = ('colour/%s'%(colour,), 'size/%s'%(size,)), + categories_list = ('colour/%s'%(colour,), 'size/%s'%(size,)), + quantity = self.order_line_colour_size_quantity_dict[colour][size] + ) + size_count +=1 + size_count = 0 + colour_count +=1 + + 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') + + for order_movement in order.getMovementList(): + size = order_movement.getSize() + colour = order_movement.getColour() + + 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__) + LOG('object.getOrderValue().getQuantity()',0,object.getOrderValue().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' % transformation.getId() + 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 unset + sequence_string = bootstrap_sequence_string + '\ + CreateTransformation \ + Tic \ + CreateOrderLineWithoutTransformation \ + Tic \ + CheckOrderLineTransformationIsSet \ + RemoveResourceFromOrderLine \ + Tic \ + CheckOrderLineTransformationIsNotSet \ + ' + 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 diff --git a/product/ERP5/tests/testLegacyProductionPackingList.py b/product/ERP5/tests/testLegacyProductionPackingList.py new file mode 100644 index 0000000000..307456fc65 --- /dev/null +++ b/product/ERP5/tests/testLegacyProductionPackingList.py @@ -0,0 +1,781 @@ +# -*- coding: utf-8 -*- +############################################################################## +# +# Copyright (c) 2008 Nexedi SA and Contributors. All Rights Reserved. +# Åukasz Nowak <lukasz.nowak@ventis.com.pl> +# +# WARNING: This program as such is intended to be used by professional +# programmers who take the whole responsibility 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 +# guarantees 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 + +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from testLegacyProductionOrder import TestProductionOrderMixin +from testLegacyPackingList import TestPackingListMixin + +class TestProductionPackingReportListMixin(TestProductionOrderMixin, TestPackingListMixin, \ + ERP5TypeTestCase): + """Mixin for testing Production Packing Lists and Production Reports""" + + def modifyPackingListState(self, transition_name, + sequence,packing_list=None): + """ calls the workflow for the packing list """ + if packing_list is None: + packing_list = sequence.get('packing_list') + packing_list.portal_workflow.doActionFor(packing_list, transition_name) + + def stepAcceptDecisionSupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self._solveDivergence(packing_list, 'quantity', 'accept') + + def stepAcceptDecisionProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self._solveDivergence(packing_list, 'quantity', 'accept') + + def stepAdoptPrevisionSupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self._solveDivergence(packing_list, 'quantity', 'adopt') + + def stepAdoptPrevisionProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self._solveDivergence(packing_list, 'quantity', 'adopt') + + def stepAdoptPrevisionProducedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + self._solveDivergence(packing_list, 'quantity', 'adopt') + + def stepAdoptPrevisionConsumedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + self._solveDivergence(packing_list, 'quantity', 'adopt') + + def stepSetReadyProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self.modifyPackingListState('set_ready_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'ready') + + def stepStartProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self.modifyPackingListState('start_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'started') + + def stepStopProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self.modifyPackingListState('stop_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'stopped') + + def stepDeliverProducedDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + self.modifyPackingListState('deliver_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'delivered') + + def stepSetReadySupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self.modifyPackingListState('set_ready_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'ready') + + def stepStartSupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self.modifyPackingListState('start_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'started') + + def stepStopSupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self.modifyPackingListState('stop_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'stopped') + + def stepDeliverSupplyDeliveryPackingList(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + self.modifyPackingListState('deliver_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'delivered') + + def stepSetReadyProducedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + self.modifyPackingListState('set_ready_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'ready') + + def stepStartProducedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + self.modifyPackingListState('start_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'started') + + def stepStopProducedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + self.modifyPackingListState('stop_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'stopped') + + def stepDeliverProducedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + self.modifyPackingListState('deliver_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'delivered') + + def stepSetReadyConsumedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + self.modifyPackingListState('set_ready_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'ready') + + def stepStartConsumedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + self.modifyPackingListState('start_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'started') + + def stepStopConsumedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + self.modifyPackingListState('stop_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'stopped') + + def stepDeliverConsumedReport(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + self.modifyPackingListState('deliver_action', sequence=sequence, packing_list=packing_list) + self.assertEquals(packing_list.getSimulationState(), 'delivered') + + def stepDecreaseProducedDeliveryPackingListQuantity(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + for line in packing_list.getMovementList(): + line.edit( + quantity = line.getQuantity() - 1.0 + ) + + def stepDecreaseSupplyDeliveryPackingListQuantity(self, sequence=None, sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + for line in packing_list.getMovementList(): + line.edit( + quantity = line.getQuantity() - 1.0 + ) + + def stepCheckSourcingDeliverySimulationDecreasedQuantity(self, sequence=None, \ + sequence_list=None, **kw): + """ + TODO + """ + self.logMessage('TODO') + + def stepCheckSourcingDeliverySimulation(self, sequence=None, \ + sequence_list=None, **kw): + """ + Hardcoded delivery checks + """ + self.stepCheckSourcingSimulation(sequence,sequence_list,**kw) + + produced_movement = sequence.get('produced_movement') + operation_movement = sequence.get('operation_movement') + component_movement = sequence.get('component_movement') + supply_movement = sequence.get('supply_movement') + produced_delivery_movement = sequence.get('produced_delivery_movement') + + produced_delivery_packing_list = produced_delivery_movement.getDeliveryValue().getParentValue() + supply_delivery_packing_list = supply_movement.getDeliveryValue().getParentValue() + + produced_report = produced_movement.getDeliveryValue().getParentValue() + + operation_report = operation_movement.getDeliveryValue().getParentValue() + component_report = component_movement.getDeliveryValue().getParentValue() + self.assertEquals(operation_report, component_report) + consumed_report = operation_report + + # checks that simulations are same + # TODO: resources, quantities, dates, ... + self.assertEquals( + produced_delivery_movement.getSimulationState(), + produced_delivery_packing_list.getSimulationState() + ) + + self.assertEquals( + supply_movement.getSimulationState(), + supply_delivery_packing_list.getSimulationState() + ) + + self.assertEquals( + produced_movement.getSimulationState(), + produced_report.getSimulationState() + ) + + self.assertEquals( + component_movement.getSimulationState(), + consumed_report.getSimulationState() + ) + + self.assertEquals( + operation_movement.getSimulationState(), + consumed_report.getSimulationState() + ) + + sequence.edit( + produced_delivery_packing_list = produced_delivery_packing_list, + supply_delivery_packing_list = supply_delivery_packing_list, + produced_report = produced_report, + consumed_report = consumed_report, + ) + + def stepCheckProducedDeliveryPackingListIsConfirmed(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + self.assertEquals( + 'confirmed', + packing_list.getSimulationState() + ) + + def stepCheckProducedDeliveryPackingListIsDelivered(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + self.assertEquals( + 'delivered', + packing_list.getSimulationState() + ) + + def stepCheckSupplyDeliveryPackingListIsDelivered(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + self.assertEquals( + 'delivered', + packing_list.getSimulationState() + ) + + def stepCheckProducedReportIsDelivered(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + + self.assertEquals( + 'delivered', + packing_list.getSimulationState() + ) + + def stepCheckConsumedReportIsDelivered(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + + self.assertEquals( + 'delivered', + packing_list.getSimulationState() + ) + + def stepCheckProducedDeliveryPackingListIsSolved(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + self.assertEquals( + 'solved', + packing_list.getCausalityState() + ) + + def stepCheckProducedDeliveryPackingListIsDiverged(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + self.assertEquals( + 'diverged', + packing_list.getCausalityState() + ) + + def stepCheckProducedDeliveryPackingListIsCalculating(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_delivery_packing_list') + + self.assertEquals( + 'calculating', + packing_list.getCausalityState() + ) + + def stepCheckSupplyDeliveryPackingListIsCalculating(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + self.assertEquals( + 'calculating', + packing_list.getCausalityState() + ) + + def stepCheckSupplyDeliveryPackingListIsConfirmed(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + self.assertEquals( + 'confirmed', + packing_list.getSimulationState() + ) + + def stepCheckSupplyDeliveryPackingListIsSolved(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + self.assertEquals( + 'solved', + packing_list.getCausalityState() + ) + + def stepCheckSupplyDeliveryPackingListIsDiverged(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('supply_delivery_packing_list') + + self.assertEquals( + 'diverged', + packing_list.getCausalityState() + ) + + def stepCheckProducedReportIsConfirmed(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + + self.assertEquals( + 'confirmed', + packing_list.getSimulationState() + ) + + def stepCheckProducedReportIsSolved(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + + self.assertEquals( + 'solved', + packing_list.getCausalityState() + ) + + def stepCheckProducedReportIsDiverged(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('produced_report') + + self.assertEquals( + 'diverged', + packing_list.getCausalityState() + ) + + def stepCheckConsumedReportIsConfirmed(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + + self.assertEquals( + 'confirmed', + packing_list.getSimulationState() + ) + + def stepCheckConsumedReportIsSolved(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + + self.assertEquals( + 'solved', + packing_list.getCausalityState() + ) + + def stepCheckConsumedReportIsDiverged(self, sequence=None, \ + sequence_list=None, **kw): + packing_list = sequence.get('consumed_report') + + self.assertEquals( + 'diverged', + packing_list.getCausalityState() + ) + +class TestProductionDelivery(TestProductionPackingReportListMixin): + """Test Production Packing Lists and Reports, mostly based on Production Orders""" + + run_all_test = 1 + + def getTitle(self): + return "Production Delivery: transformation type %s, resource type %s"%( + self.transformation_portal_type, + self.resource_portal_type,) + + def test_01_sourcingDelivery(self, quiet=0, + run=run_all_test): + """ + Test for sourcing type of delivery (Production Report and Production Packing Lists). + """ + # XXX: Need to split to separate test (Luke) + if not run: return + + delivery_check_sequence_string = self.SOURCING_ORDER_SEQUENCE + '\ + CheckSourcingDeliverySimulation \ + \ + CheckProducedDeliveryPackingListIsConfirmed \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsConfirmed \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsSolved\ + \ + ' + + sequence_list = SequenceList() + # Check states of deliveries, just after order confirmation + sequence_string = delivery_check_sequence_string + sequence_list.addSequenceString(sequence_string) + + # Test when packing list are delivered one by one + # Note: I (Luke) know, that below sequence is long + # but I wanted to be sure, that full production + # process is doable. + sequence_string = delivery_check_sequence_string + '\ + SetReadyProducedDeliveryPackingList \ + StartProducedDeliveryPackingList \ + StopProducedDeliveryPackingList \ + DeliverProducedDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulation \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsConfirmed \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsSolved\ + \ + SetReadySupplyDeliveryPackingList \ + StartSupplyDeliveryPackingList \ + StopSupplyDeliveryPackingList \ + DeliverSupplyDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulation \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsSolved\ + \ + SetReadyProducedReport \ + StartProducedReport \ + StopProducedReport \ + DeliverProducedReport \ + Tic \ + \ + CheckSourcingDeliverySimulation \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsSolved\ + \ + SetReadyConsumedReport \ + StartConsumedReport \ + StopConsumedReport \ + DeliverConsumedReport \ + Tic \ + \ + CheckSourcingDeliverySimulation \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsDelivered \ + CheckConsumedReportIsSolved\ + \ + ' + sequence_list.addSequenceString(sequence_string) + + # Check a case, when Produced Delivery Packing List is diverged + # then accept this decision, next deliver it, then adopt prevision + # on rest of documents and deliver them - do it one by one + sequence_string = delivery_check_sequence_string + '\ + DecreaseProducedDeliveryPackingListQuantity \ + \ + CheckProducedDeliveryPackingListIsCalculating \ + Tic \ + CheckProducedDeliveryPackingListIsDiverged \ + AcceptDecisionProducedDeliveryPackingList \ + Tic \ + CheckProducedDeliveryPackingListIsSolved \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckSupplyDeliveryPackingListIsConfirmed \ + CheckSupplyDeliveryPackingListIsDiverged\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadyProducedDeliveryPackingList \ + StartProducedDeliveryPackingList \ + StopProducedDeliveryPackingList \ + DeliverProducedDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsConfirmed \ + CheckSupplyDeliveryPackingListIsDiverged\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionSupplyDeliveryPackingList \ + Tic \ + CheckSupplyDeliveryPackingListIsSolved \ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadySupplyDeliveryPackingList \ + StartSupplyDeliveryPackingList \ + StopSupplyDeliveryPackingList \ + DeliverSupplyDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionProducedReport \ + Tic \ + CheckProducedReportIsSolved \ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadyProducedReport \ + StartProducedReport \ + StopProducedReport \ + DeliverProducedReport \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved \ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionConsumedReport \ + Tic \ + CheckProducedReportIsSolved \ + \ + SetReadyConsumedReport \ + StartConsumedReport \ + StopConsumedReport \ + DeliverConsumedReport \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsDelivered \ + CheckConsumedReportIsSolved\ + \ + ' + sequence_list.addSequenceString(sequence_string) + + # Check a case, when Consumed Delivery Packing List is diverged + # then accept this decision, next deliver it, then adopt prevision + # on rest of documents and deliver them - do it one by one + sequence_string = delivery_check_sequence_string + '\ + DecreaseSupplyDeliveryPackingListQuantity \ + \ + CheckSupplyDeliveryPackingListIsCalculating \ + Tic \ + CheckSupplyDeliveryPackingListIsDiverged \ + AcceptDecisionSupplyDeliveryPackingList \ + Tic \ + CheckSupplyDeliveryPackingListIsSolved \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsConfirmed \ + CheckProducedDeliveryPackingListIsDiverged\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsSolved \ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadySupplyDeliveryPackingList \ + StartSupplyDeliveryPackingList \ + StopSupplyDeliveryPackingList \ + DeliverSupplyDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedDeliveryPackingListIsConfirmed \ + CheckProducedDeliveryPackingListIsDiverged\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionProducedDeliveryPackingList \ + Tic \ + CheckProducedDeliveryPackingListIsSolved \ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadyProducedDeliveryPackingList \ + StartProducedDeliveryPackingList \ + StopProducedDeliveryPackingList \ + DeliverProducedDeliveryPackingList \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsConfirmed \ + CheckProducedReportIsDiverged\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionProducedReport \ + Tic \ + CheckProducedReportIsSolved \ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + SetReadyProducedReport \ + StartProducedReport \ + StopProducedReport \ + DeliverProducedReport \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved \ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsConfirmed \ + CheckConsumedReportIsDiverged\ + \ + AdoptPrevisionConsumedReport \ + Tic \ + CheckProducedReportIsSolved \ + \ + SetReadyConsumedReport \ + StartConsumedReport \ + StopConsumedReport \ + DeliverConsumedReport \ + Tic \ + \ + CheckSourcingDeliverySimulationDecreasedQuantity \ + \ + CheckProducedDeliveryPackingListIsDelivered \ + CheckProducedDeliveryPackingListIsSolved\ + \ + CheckSupplyDeliveryPackingListIsDelivered \ + CheckSupplyDeliveryPackingListIsSolved\ + \ + CheckProducedReportIsDelivered \ + CheckProducedReportIsSolved\ + \ + CheckConsumedReportIsDelivered \ + CheckConsumedReportIsSolved\ + \ + ' + sequence_list.addSequenceString(sequence_string) + + sequence_list.play(self) + +def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestProductionDelivery)) + return suite -- 2.30.9