diff --git a/product/ERP5/tests/testERP5Simulation.py b/product/ERP5/tests/testERP5Simulation.py index 28ffde70e7eaf3aa8017235bbe7700186bad596a..a5180d8f08ddbf78756545acf98ce4356a7bfab7 100644 --- a/product/ERP5/tests/testERP5Simulation.py +++ b/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