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