create a simple test class that will check new simulation API.

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@31396 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/ERP5/tests/testERP5Simulation.py

@@ -32,6 +32,8 @@ This test is experimental for new simulation implementation.
 import unittest
 import transaction
 
+from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
+from Products.ERP5Type.tests.Sequence import SequenceList
 from testPackingList import TestPackingList, TestPackingListMixin
 
 class TestERP5SimulationMixin(TestPackingListMixin):
@@ -49,6 +51,160 @@ class TestERP5SimulationMixin(TestPackingListMixin):
       if rule.getValidationState() == 'validated':
         rule.invalidate()
 
+class TestERP5Simulation(TestERP5SimulationMixin, ERP5TypeTestCase):
+  run_all_test = 1
+  quiet = 0
+
+  def validateNewRules(self):
+    # create a New Order Rule document.
+    portal_rules = self.portal.portal_rules
+    try:
+      new_order_rule = filter(
+        lambda x:x.title == 'New Default Order Rule',
+        portal_rules.objectValues(portal_type='New Order Rule'))[0]
+    except IndexError:
+      new_order_rule = portal_rules.newContent(
+        title='New Default Order Rule',
+        portal_type='New Order Rule',
+        reference='default_order_rule',
+        version=2,
+        )
+      # create category divergence testers that is only used for matching
+      for i in ('order',):
+        new_order_rule.newContent(
+          title='%s divergence tester' % i,
+          portal_type='Category Membership Divergence Tester',
+          tested_property=i,
+          divergence_provider=0,
+          matching_provider=1)
+      # create float divergence testers
+      for i in ('converted_quantity',):
+        new_order_rule.newContent(
+          title='%s divergence tester' % i,
+          portal_type='Float Divergence Tester',
+          tested_property=i,
+          use_delivery_ratio=1,
+          quantity_range_min=-1,
+          quantity_range_max=2)
+    if new_order_rule.getValidationState() != 'validated':
+      new_order_rule.validate()
+
+  def _modifyPackingListLineQuantity(self, sequence=None,
+      sequence_list=None, delta=0.0):
+    """
+    Set a increased quantity on packing list lines
+    """
+    packing_list = sequence.get('packing_list')
+    quantity = self.default_quantity + delta
+    sequence.edit(line_quantity=quantity)
+    for packing_list_line in packing_list.objectValues(
+        portal_type=self.packing_list_line_portal_type):
+      packing_list_line.edit(quantity=quantity)
+    sequence.edit(last_delta=delta)
+
+  def stepIncreasePackingListLineQuantity2(self, sequence=None,
+      sequence_list=None, **kw):
+    return self._modifyPackingListLineQuantity(sequence, sequence_list, 2.0)
+
+  def stepDecreasePackingListLineQuantity1(self, sequence=None,
+      sequence_list=None, **kw):
+    return self._modifyPackingListLineQuantity(sequence, sequence_list, -1.0)
+
+  def stepDecreasePackingListLineQuantity10(self, sequence=None,
+      sequence_list=None, **kw):
+    return self._modifyPackingListLineQuantity(sequence, sequence_list, -10.0)
+
+  def stepSplitAndDeferPackingList(self, sequence=None, sequence_list=None, **kw):
+    """
+      Do the split and defer action
+    """
+    packing_list = sequence.get('packing_list')
+    solver_tool = self.portal.portal_solvers
+    solver_process = solver_tool.newSolverProcess(packing_list)
+    quantity_solver_decision = filter(
+      lambda x:x.getCausalityValue().getTestedProperty()=='converted_quantity',
+      solver_process.contentValues())[0]
+    # use Quantity Split Solver.
+    quantity_solver_decision.setSolverValue(self.portal.portal_types['Quantity Split Solver'])
+    # configure for Quantity Split Solver.
+    kw = {'delivery_solver':'FIFO',
+          'start_date':packing_list.getStartDate() + 10}
+    quantity_solver_decision.updateConfiguration(**kw)
+    solver_process.buildTargetSolverList()
+    solver_process.solve()
+    # build split deliveries manually. XXX ad-hoc
+    previous_tag = None
+    for delivery_builder in packing_list.getBuilderList():
+      this_builder_tag = '%s_split_%s' % (packing_list.getPath(),
+                                          delivery_builder.getId())
+      after_tag = []
+      if previous_tag:
+        after_tag.append(previous_tag)
+      delivery_builder.activate(
+        after_method_id=('solve',
+                         'immediateReindexObject',
+                         'recursiveImmediateReindexObject',), # XXX too brutal.
+        after_tag=after_tag,
+        ).build(explanation_uid=packing_list.getCausalityValue().getUid())
+
+  def stepCheckPackingListSplitted(self, sequence=None, sequence_list=None, **kw):
+    """
+      Test if packing list was splitted
+    """
+    order = sequence.get('order')
+    packing_list_list = order.getCausalityRelatedValueList(
+                               portal_type=self.packing_list_portal_type)
+    self.assertEquals(2,len(packing_list_list))
+    packing_list1 = None
+    packing_list2 = None
+    for packing_list in packing_list_list:
+      if packing_list.getUid() == sequence.get('packing_list').getUid():
+        packing_list1 = packing_list
+      else:
+        packing_list2 = packing_list
+    sequence.edit(new_packing_list=packing_list2)
+    for line in packing_list1.objectValues(
+          portal_type= self.packing_list_line_portal_type):
+      self.assertEquals(self.default_quantity-10,line.getQuantity())
+    for line in packing_list2.objectValues(
+          portal_type= self.packing_list_line_portal_type):
+      self.assertEquals(10,line.getQuantity())
+
+  def test_01_splitAndDefer(self, quiet=quiet, run=run_all_test):
+    """
+      Change the quantity on an delivery line, then
+      see if the packing list is divergent and then
+      split and defer the packing list
+    """
+    if not run: return
+    sequence_list = SequenceList()
+
+    # Test with a simply order without cell
+    sequence_string = self.default_sequence + '\
+                      stepIncreasePackingListLineQuantity2 \
+                      stepCheckPackingListIsCalculating \
+                      stepTic \
+                      stepCheckPackingListIsNotDivergent \
+                      stepCheckPackingListIsSolved \
+                      stepDecreasePackingListLineQuantity1 \
+                      stepCheckPackingListIsCalculating \
+                      stepTic \
+                      stepCheckPackingListIsNotDivergent \
+                      stepCheckPackingListIsSolved \
+                      stepDecreasePackingListLineQuantity10 \
+                      stepCheckPackingListIsCalculating \
+                      stepTic \
+                      stepCheckPackingListIsDiverged \
+                      stepSplitAndDeferPackingList \
+                      stepTic \
+                      stepCheckPackingListSplitted \
+                      stepCheckPackingListIsSolved \
+                      '
+    sequence_list.addSequenceString(sequence_string)
+
+    sequence_list.play(self, quiet=quiet)
+
+class TestERP5SimulationPackingList(TestERP5SimulationMixin, TestPackingList):
   def validateNewRules(self):
     # create a New Order Rule document.
     portal_rules = self.portal.portal_rules
@@ -124,7 +280,6 @@ class TestERP5SimulationMixin(TestPackingListMixin):
     if new_order_rule.getValidationState() != 'validated':
       new_order_rule.validate()
 
-class TestERP5Simulation(TestERP5SimulationMixin, TestPackingList):
   def stepAcceptDecisionQuantity(self,sequence=None, sequence_list=None, **kw):
     """
     Solve quantity divergence by using solver tool.
@@ -195,4 +350,5 @@ class TestERP5Simulation(TestERP5SimulationMixin, TestPackingList):
 def test_suite():
   suite = unittest.TestSuite()
   suite.addTest(unittest.makeSuite(TestERP5Simulation))
+  suite.addTest(unittest.makeSuite(TestERP5SimulationPackingList))
   return suite