diff --git a/product/ERP5Banking/tests/testERP5BankingCounterRendering.py b/product/ERP5Banking/tests/testERP5BankingCounterRendering.py new file mode 100644 index 0000000000000000000000000000000000000000..b857504c168c55bd518da0cf4d259dc6d9eef200 --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingCounterRendering.py @@ -0,0 +1,516 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Contributors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingCounterRendering(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Counter Rendering + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a counter rendering + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingCounterRendering" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_counter_rendering-0.1.bt5' # erp5_banking_cash contains all method for counter rendering + ) + + def getCounterRenderingModule(self): + """ + Return the Cash Transer Module + """ + return getattr(self.getPortal(), 'counter_rendering_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the cahs transfer module + self.counter_rendering_module = self.getCounterRenderingModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.piece_200, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_200} + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + self.usual_cash = self.paris.surface.caisse_courante.encaisse_des_billets_et_monnaies + self.counter = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies + self.createCashInventory(source=None, destination=self.counter, currency=self.currency_1, + line_list=line_list) + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that CounterRendering Module was created + self.assertEqual(self.counter_rendering_module.getPortalType(), 'Counter Rendering Module') + # check counter rendering module is empty + self.assertEqual(len(self.counter_rendering_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (usual_cash) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (counter) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCreateCounterRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Create a counter rendering document and check it + """ + # Counter rendering has usual_cash for source, counter for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + + self.counter_rendering = self.counter_rendering_module.newContent(id='counter_rendering_1', portal_type='Counter Rendering', source_value=self.counter, source_total_asset_price=52400.0) + # execute tic + self.stepTic() + # check we have only one counter rendering + self.assertEqual(len(self.counter_rendering_module.objectValues()), 1) + # get the counter rendering document + self.counter_rendering = getattr(self.counter_rendering_module, 'counter_rendering_1') + # check its portal type + self.assertEqual(self.counter_rendering.getPortalType(), 'Counter Rendering') + # check that its source is usual_cash + self.assertEqual(self.counter_rendering.getSource(), 'site/testsite/paris/surface/banque_interne/guichet_1/encaisse_des_billets_et_monnaies') + # check that its destination is counter + #self.assertEqual(self.counter_rendering.getDestination(), 'site/testsite/paris/surface/caisse_courante/encaisse_des_billets_et_monnaies') + + + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the counter rendering line 1 with banknotes of 10000 and check it has been well created + """ + # create the counter rendering line + self.addCashLineToDelivery(self.counter_rendering, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.counter_rendering.objectValues()), 1) + # get the counter rendering line + self.valid_line_1 = getattr(self.counter_rendering, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is usual_cash + self.assertEqual(cell.getSourceValue(), self.counter) + # check the destination vault is counter + #self.assertEqual(cell.getDestinationValue(), self.usual_cash) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of counter rendering line 1 + """ + # Check number of lines + self.assertEqual(len(self.counter_rendering.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.counter_rendering.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.counter_rendering.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the counter rendering line 2 wiht coins of 200 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.counter_rendering, 'valid_line_2', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.counter_rendering.objectValues()), 2) + # get the second counter rendering line + self.valid_line_2 = getattr(self.counter_rendering, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is coin of 200 + self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) + # check the value of coin + self.assertEqual(self.valid_line_2.getPrice(), 200.0) + # check the unit of coin + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for coin for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 5.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for coin for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 7.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid counter rendering line and + check the total with the invalid counter rendering line + """ + # create a line in which quanity of banknotes of 5000 is higher that quantity available at source + # here create a line with 24 (11+13) banknotes of 500 although the vault usual_cash has no banknote of 5000 + self.addCashLineToDelivery(self.counter_rendering, 'invalid_line', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # Check number of counter rendering lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.counter_rendering.objectValues()), 3) + # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 + self.assertEqual(self.counter_rendering.getTotalQuantity(), 5.0 + 12.0 + 24) + # chect the total price + self.assertEqual(self.counter_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) + + + def stepTryConfirmCounterRenderingWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the counter rendering with a bad counter rendering line and + check the try of confirm the counter rendering with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.counter_rendering.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.counter_rendering, 'confirm_action', wf_id='counter_rendering_workflow') + # execute tic + self.stepTic() + # get state of the counter rendering + state = self.counter_rendering.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.counter_rendering, name='history', wf_id='counter_rendering_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid counter rendering line previously create + """ + self.counter_rendering.deleteContent('invalid_line') + + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two counter rendering lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.counter_rendering.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 + self.assertEqual(self.counter_rendering.getTotalQuantity(), 5.0 + 12.0) + # check the total price + self.assertEqual(self.counter_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) + + + def stepConfirmCounterRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the counter rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.counter_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.counter_rendering, 'confirm_action', wf_id='counter_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.counter_rendering.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.counter_rendering, name='history', wf_id='counter_rendering_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault usual_cash is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault counter is right after confirm and before deliver + """ + + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepDeliverCounterRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the counter rendering with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.counter_rendering, 'deliver_action', wf_id='counter_rendering_workflow') + # execute tic + self.stepTic() + # get state of counter rendering + state = self.counter_rendering.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.counter_rendering, name='history', wf_id='counter_rendering_workflow') + # check len of len workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault usual_cash) after deliver of the counter rendering + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault counter) after deliver of the counter rendering + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + ################################## + ## Tests + ################################## + + def test_01_ERP5BankingCounterRendering(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ + + 'CreateCounterRendering ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource CheckDestination ' \ + + 'CreateInvalidLine ' \ + + 'TryConfirmCounterRenderingWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'ConfirmCounterRendering ' \ + + 'Tic CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'DeliverCounterRendering ' \ + + 'CheckSourceDebit CheckDestinationCredit ' + sequence_list.addSequenceString(sequence_string) + # play the sequence + sequence_list.play(self) + +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingCounterRendering)) + return suite diff --git a/product/ERP5Banking/tests/testERP5BankingMonetaryDestruction.py b/product/ERP5Banking/tests/testERP5BankingMonetaryDestruction.py new file mode 100644 index 0000000000000000000000000000000000000000..225ea6501622c9accc5d1b0f66e0e9adc7b75116 --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingMonetaryDestruction.py @@ -0,0 +1,791 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Contributors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingMonetaryDestruction(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Monetary Destruction + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a monetary destruction + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingMonetaryDestruction" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_monetary_destruction' # erp5_banking_monetary_destruction contains all method for monetary destruction + ) + + def getMonetaryDestructionModule(self): + """ + Return the Monetary Destruction Module + """ + return getattr(self.getPortal(), 'monetary_destruction_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the monetary destruction module + self.monetary_destruction_module = self.getMonetaryDestructionModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.billet_5000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_5000} + + inventory_dict_line_for_externe_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/s', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_for_externe_2 = {'id' : 'inventory_line_2', + 'resource': self.billet_5000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/s', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_5000} + + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + line_list_for_externe = [inventory_dict_line_for_externe_1, inventory_dict_line_for_externe_2] + self.source = self.paris.caveau.serre.encaisse_des_billets_retires_de_la_circulation + self.source_for_externe = self.paris.caveau.externes.encaisse_des_externes + ###self.destinat = self.paris.caveau.serre.encaisse_des_billets_detruits + self.createCashInventory(source=None, destination=self.source, currency=self.currency_1, + line_list=line_list) + self.createCashInventory(source=None, destination=self.source_for_externe, currency=self.currency_1, + line_list=line_list_for_externe) + + # now we need to create a user as Manager to do the test + # in order to have an assigment defined which is used to do transition + # Create an Organisation that will be used for users assignment + self.checkUserFolderType() + self.organisation = self.organisation_module.newContent(id='baobab_org', portal_type='Organisation', + function='banking', group='baobab', site='testsite/paris') + + self.organisation_externe = self.organisation_module.newContent(id='baobab_org_externe', portal_type='Organisation', + function='banking', group='baobab', site='testsite/madrid') + + + # define the user + user_dict = { + 'super_user' : [['Manager'], self.organisation, 'banking/comptable', 'baobab', 'testsite/paris'] + } + # call method to create this user + self.createERP5Users(user_dict) + self.logout() + self.login('super_user') + + + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that Monetary Destruction Module was created + self.assertEqual(self.monetary_destruction_module.getPortalType(), 'Monetary Destruction Module') + # check monetary destruction module is empty + self.assertEqual(len(self.monetary_destruction_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in source + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 24 banknotes of 5000 in source + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + + + def stepCheckInitialInventoryForExterne(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in source + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 24 banknotes of 5000 in source + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + + + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (source) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 24 banknotes of 5000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + + + + def stepCheckSourceForExterne(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (source) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 24 banknotes of 5000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + + + + def stepCreateMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Create a monetary destruction document and check it + """ + #print self.portal.portal_categories.objectIds() + # Monetary Destruction has source(serre) for source, destinat (serre) for destination, and a price coresponding to the sum of banknote of 10000 and of 5000 ( (2*3) * 10000 + (5*7) * 5000 ) + self.monetary_destruction = self.monetary_destruction_module.newContent(id='monetary_destruction_1', portal_type='Monetary Destruction', source_value=self.source, destination_value=None, source_total_asset_price=110000.0) + # execute tic + self.stepTic() + # check we have only one monetary destruction + self.assertEqual(len(self.monetary_destruction_module.objectValues()), 1) + # get the monetary destruction document + self.monetary_destruction = getattr(self.monetary_destruction_module, 'monetary_destruction_1') + # check its portal type + self.assertEqual(self.monetary_destruction.getPortalType(), 'Monetary Destruction') + # check that its source is source + self.assertEqual(self.monetary_destruction.getSource(), 'site/testsite/paris/caveau/serre/encaisse_des_billets_retires_de_la_circulation') + # check that its destination is destinat + ##self.assertEqual(self.monetary_destruction.getDestination(), 'site/testsite/paris/caveau/serre/encaisse_des_billets_detruits') + + + def stepCreateMonetaryDestructionForExterne(self, sequence=None, sequence_list=None, **kwd): + """ + Create a monetary destruction document and check it + """ + # Monetary Destruction has source(serre) for source, destinat (serre) for destination, and a price coresponding to the sum of banknote of 10000 and of 5000 ( (2*3) * 10000 + (5*7) * 5000 ) + self.monetary_destruction = self.monetary_destruction_module.newContent(id='monetary_destruction_1', portal_type='Monetary Destruction', source_value=self.source_for_externe, destination_value=None, source_total_asset_price=110000.0) + # execute tic + self.stepTic() + # check we have only one monetary destruction + self.assertEqual(len(self.monetary_destruction_module.objectValues()), 1) + # get the monetary destruction document + self.monetary_destruction = getattr(self.monetary_destruction_module, 'monetary_destruction_1') + # check its portal type + self.assertEqual(self.monetary_destruction.getPortalType(), 'Monetary Destruction') + # check that its source is source + self.assertEqual(self.monetary_destruction.getSource(), 'site/testsite/paris/caveau/externes/encaisse_des_externes') + # check that its destination is destinat + ##self.assertEqual(self.monetary_destruction.getDestination(), 'site/testsite/paris/caveau/serre/encaisse_des_billets_detruits') + + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary destruction line 1 with banknotes of 10000 and check it has been well created + """ + # create the monetary destruction line + self.addCashLineToDelivery(self.monetary_destruction, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.monetary_destruction.objectValues()), 1) + # get the monetary destruction line + self.valid_line_1 = getattr(self.monetary_destruction, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/cancelled') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is source + self.assertEqual(cell.getSourceValue(), self.source) + # check the destination vault is counter + #self.assertEqual(cell.getDestinationValue(), self.destinat) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateValidLineForExterne1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary destruction line 1 with banknotes of 10000 and check it has been well created + """ + # create the monetary destruction line + self.addCashLineToDelivery(self.monetary_destruction, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/s', 'cash_status/cancelled') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.monetary_destruction.objectValues()), 1) + # get the monetary destruction line + self.valid_line_1 = getattr(self.monetary_destruction, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/s', variation, 'cash_status/cancelled') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is source + self.assertEqual(cell.getSourceValue(), self.source_for_externe) + # check the destination vault is counter + #self.assertEqual(cell.getDestinationValue(), self.destinat) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of monetary destruction line 1 + """ + # Check number of lines + self.assertEqual(len(self.monetary_destruction.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.monetary_destruction.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.monetary_destruction.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary destruction line 2 wiht banknotes of 5000 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.monetary_destruction, 'valid_line_2', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.monetary_destruction.objectValues()), 2) + # get the second monetary destruction line + self.valid_line_2 = getattr(self.monetary_destruction, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 5000 + self.assertEqual(self.valid_line_2.getResourceValue(), self.billet_5000) + # check the value of banknote + self.assertEqual(self.valid_line_2.getPrice(), 5000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/cancelled') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for banknote for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 11.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for banknote for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 13.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateValidLineForExterne2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary destruction line 2 wiht banknotes of 5000 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.monetary_destruction, 'valid_line_2', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/s', 'cash_status/cancelled') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.monetary_destruction.objectValues()), 2) + # get the second monetary destruction line + self.valid_line_2 = getattr(self.monetary_destruction, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 5000 + self.assertEqual(self.valid_line_2.getResourceValue(), self.billet_5000) + # check the value of banknote + self.assertEqual(self.valid_line_2.getPrice(), 5000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/s', variation, 'cash_status/cancelled') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for banknote for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 11.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for banknote for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 13.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid monetary destruction line and + check the total with the invalid monetary destruction line + """ + # create a line in which quanity of coin of 200 is higher that quantity available at source + # here create a line with 12 (5+7) coin of 200 although the vault source has no coin of 200 + self.addCashLineToDelivery(self.monetary_destruction, 'invalid_line', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # Check number of monetary destruction lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.monetary_destruction.objectValues()), 3) + # Check quantity, same as checkTotal + coin of 200: 5 for 1992 and 7 for 2003 + self.assertEqual(self.monetary_destruction.getTotalQuantity(), 5.0 + 24.0 + 12) + # chect the total price + self.assertEqual(self.monetary_destruction.getTotalPrice(), 10000 * 5.0 + 5000 * 24.0 + 200 * 12) + + def stepTryPlannedMonetaryDestructionWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the monetary destruction with a bad monetary destruction line and + check the try of confirm the monetary destruction with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 5000 * 24.0 + 200 * 12) + + self.monetary_destruction.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.monetary_destruction, 'plan_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state of the monetary destruction + state = self.monetary_destruction.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid monetary destruction line previously create + """ + self.monetary_destruction.deleteContent('invalid_line') + + def stepDelMonetrayDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid monetary_destruction line previously create + """ + self.monetary_destruction.deleteContent('monetary_destruction_1') + + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two monetary destruction lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.monetary_destruction.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, banknotes : 5 for 1992 and 7 for 2003 + self.assertEqual(self.monetary_destruction.getTotalQuantity(), 5.0 + 24.0) + # check the total price + self.assertEqual(self.monetary_destruction.getTotalPrice(), 10000 * 5.0 + 5000 * 24.0) + + + def stepPlannedMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the monetary destruction and check it + """ + # fix amount (10000 * 5.0 + 5000 * 24.0) + self.monetary_destruction.setSourceTotalAssetPrice('170000.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.monetary_destruction, 'plan_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state + state = self.monetary_destruction.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'planned') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault source is right after confirm and before deliver + """ + print self.monetary_destruction.getBaobabDestination() + print self.monetary_destruction.getBaobabDestinationUid() + + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 24 banknotes of 5000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + # check we will have 0 banknote of 5000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + + + def stepCheckSourceDebitPlannedForExterne(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault source is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 24 banknotes of 5000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0) + # check we will have 0 banknote of 5000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + + + + def stepValidateMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Validate the monetary destruction with a good user + and check that the validation of a monetary destruction have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.monetary_destruction, 'plan_to_deliver_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state of monetary destruction + state = self.monetary_destruction.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of len workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault source) after validation of the monetary destruction + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 banknote of 5000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + + + def stepCheckSourceDebitForExterne(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault source) after validation of the monetary destruction + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 banknote of 5000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.source_for_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0) + + + + + def stepPlanMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the monetary_destruction and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.monetary_destruction.setSourceTotalAssetPrice('170000.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.monetary_destruction, 'plan_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state + state = self.monetary_destruction.getSimulationState() + # check state is planned + self.assertEqual(state, 'planned') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + + def stepOrderMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the monetary_destruction and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.monetary_destruction.setSourceTotalAssetPrice('170000.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.monetary_destruction, 'order_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state + state = self.monetary_destruction.getSimulationState() + # check state is ordered + self.assertEqual(state, 'ordered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 6) + + def stepConfirmMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the monetary_destruction and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.monetary_destruction.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + import pdb;pdb.set_trace() + self.workflow_tool.doActionFor(self.monetary_destruction, 'confirm_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state + state = self.monetary_destruction.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of workflow history is 8 + self.assertEqual(len(workflow_history), 8) + + def stepConfirmToDeliverMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the monetary_destruction with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.monetary_destruction, 'deliver_action', wf_id='monetary_destruction_workflow') + # execute tic + self.stepTic() + # get state of monetary_destruction + state = self.monetary_destruction.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_destruction, name='history', wf_id='monetary_destruction_workflow') + # check len of len workflow history is 10 + self.assertEqual(len(workflow_history), 10) + + + def stepDelMonetaryDestruction(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid vault_transfer line previously create + """ + self.monetary_destruction_module.deleteContent('monetary_destruction_1') + + ################################## + ## Tests + ################################## + + def test_01_ERP5BankingMonetaryDestruction(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource ' \ + + 'CreateMonetaryDestruction ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource ' \ + + 'CreateInvalidLine ' \ + + 'TryPlannedMonetaryDestructionWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'PlannedMonetaryDestruction ' \ + + 'CheckSourceDebitPlanned ' \ + + 'ValidateMonetaryDestruction ' \ + + 'CheckSourceDebit ' + sequence_list.addSequenceString(sequence_string) + + # define the sequence + another_sequence_string = 'Tic DelMonetaryDestruction Tic CheckObjects Tic CheckInitialInventoryForExterne CheckSourceForExterne ' \ + + 'CreateMonetaryDestructionForExterne ' \ + + 'CreateValidLineForExterne1 CheckSubTotal ' \ + + 'CreateValidLineForExterne2 CheckTotal ' \ + + 'CheckSourceForExterne ' \ + + 'CreateInvalidLine ' \ + + 'TryPlannedMonetaryDestructionWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'PlanMonetaryDestruction ' \ + + 'CheckSourceDebitPlannedForExterne ' \ + + 'OrderMonetaryDestruction ' \ + + 'ConfirmMonetaryDestruction ' \ + + 'ConfirmToDeliverMonetaryDestruction ' \ + + 'CheckSourceDebitForExterne ' + + sequence_list.addSequenceString(another_sequence_string) + + + # play the sequence + sequence_list.play(self) + +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingMonetaryDestruction)) + return suite diff --git a/product/ERP5Banking/tests/testERP5BankingMonetaryRecall.py b/product/ERP5Banking/tests/testERP5BankingMonetaryRecall.py new file mode 100755 index 0000000000000000000000000000000000000000..821a76df33a9dd208009ac1ab33d087e9daef39b --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingMonetaryRecall.py @@ -0,0 +1,524 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Contributors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingMonetaryRecall(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Monetary Recall + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a monetary recall + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingMonetaryRecall" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_monetary_recall' + #, 'erp5_banking_monetary_recall-0.1.bt5' # erp5_banking_cash contains all method for monetary recall + ) + + def getMonetaryRecallModule(self): + """ + Return the Monetary Recall Module + """ + return getattr(self.getPortal(), 'monetary_recall_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the cahs transfer module + self.monetary_recall_module = self.getMonetaryRecallModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.piece_200, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + 'quantity': self.quantity_200} + + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + self.cash = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies + + ###Comment this part because the destination is automatic + #print self.paris.caveau.objectIds() + self.counter = self.paris.caveau.serre.encaisse_des_billets_retires_de_la_circulation + + self.createCashInventory(source=None, destination=self.cash, currency=self.currency_1, + line_list=line_list) + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that MonetaryRecall Module was created + self.assertEqual(self.monetary_recall_module.getPortalType(), 'Monetary Recall Module') + # check monetary recall module is empty + self.assertEqual(len(self.monetary_recall_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (cash) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (counter) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCreateMonetaryRecall(self, sequence=None, sequence_list=None, **kwd): + """ + Create a monetary recall document and check it + """ + # Cash transfer has cash for source, counter for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + #self.monetary_recall = self.monetary_recall_module.newContent(id='monetary_recall_1', portal_type='Monetary Recall', source_value=self.cash, #destination_value=self.counter, source_total_asset_price=52400.0) + self.monetary_recall = self.monetary_recall_module.newContent(id='monetary_recall_1', portal_type='Monetary Recall', source_value=self.cash, source_total_asset_price=52400.0) + + # execute tic + self.stepTic() + # check we have only one monetary recall + self.assertEqual(len(self.monetary_recall_module.objectValues()), 1) + # get the monetary recall document + self.monetary_recall = getattr(self.monetary_recall_module, 'monetary_recall_1') + # check its portal type + self.assertEqual(self.monetary_recall.getPortalType(), 'Monetary Recall') + # check that its source is cash + self.assertEqual(self.monetary_recall.getSource(), 'site/testsite/paris/caveau/auxiliaire/encaisse_des_billets_et_monnaies') + # check that its destination is counter + ##self.assertEqual(self.monetary_recall.getDestination(), + ##'site/testsite/paris/caveau/serre/encaisse_des_billets_retires_de_la_circulation') + #'site/testsite/paris/surface/banque_interne/guichet_1') + + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary recall line 1 with banknotes of 10000 and check it has been well created + """ + # create the monetary recall line + self.addCashLineToDelivery(self.monetary_recall, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.monetary_recall.objectValues()), 1) + # get the monetary recall line + self.valid_line_1 = getattr(self.monetary_recall, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/cancelled') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is cash + self.assertEqual(cell.getSourceValue(), self.cash) + # check the destination vault is counter + ##self.assertEqual(cell.getDestinationValue(), self.counter) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of monetary recall line 1 + """ + # Check number of lines + self.assertEqual(len(self.monetary_recall.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.monetary_recall.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.monetary_recall.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the monetary recall line 2 wiht coins of 200 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.monetary_recall, 'valid_line_2', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.monetary_recall.objectValues()), 2) + # get the second monetary recall line + self.valid_line_2 = getattr(self.monetary_recall, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is coin of 200 + self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) + # check the value of coin + self.assertEqual(self.valid_line_2.getPrice(), 200.0) + # check the unit of coin + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/cancelled') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for coin for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 5.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for coin for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 7.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid monetary recall line and + check the total with the invalid monetary recall line + """ + # create a line in which quanity of banknotes of 5000 is higher that quantity available at source + # here create a line with 24 (11+13) banknotes of 500 although the vault cash has no banknote of 5000 + self.addCashLineToDelivery(self.monetary_recall, 'invalid_line', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # Check number of monetary recall lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.monetary_recall.objectValues()), 3) + # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 + self.assertEqual(self.monetary_recall.getTotalQuantity(), 5.0 + 12.0 + 24) + # chect the total price + self.assertEqual(self.monetary_recall.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) + + + def stepTryConfirmMonetaryRecallWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the monetary recall with a bad monetary recall line and + check the try of confirm the monetary recall with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.monetary_recall.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.monetary_recall, 'confirm_action', wf_id='monetary_recall_workflow') + # execute tic + self.stepTic() + # get state of the monetary recall + state = self.monetary_recall.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_recall, name='history', wf_id='monetary_recall_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid monetary recall line previously create + """ + self.monetary_recall.deleteContent('invalid_line') + + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two monetary recall lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.monetary_recall.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 + self.assertEqual(self.monetary_recall.getTotalQuantity(), 5.0 + 12.0) + # check the total price + self.assertEqual(self.monetary_recall.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) + + + def stepConfirmMonetaryRecall(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the monetary recall and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.monetary_recall.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.monetary_recall, 'confirm_action', wf_id='monetary_recall_workflow') + # execute tic + self.stepTic() + # get state + state = self.monetary_recall.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_recall, name='history', wf_id='monetary_recall_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault cash is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault counter is right after confirm and before deliver + """ + #print self.monetary_recall.getBaobabDestination() + + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepDeliverMonetaryRecall(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the monetary recall with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.monetary_recall, 'deliver_action', wf_id='monetary_recall_workflow') + # execute tic + self.stepTic() + # get state of monetary recall + state = self.monetary_recall.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.monetary_recall, name='history', wf_id='monetary_recall_workflow') + # check len of len workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault cash) after deliver of the monetary recall + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault counter) after deliver of the monetary recall + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.counter.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + ################################## + ## Tests + ################################## + + def test_01_ERP5BankingMonetaryRecall(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ + + 'CreateMonetaryRecall ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource CheckDestination ' \ + + 'CreateInvalidLine ' \ + + 'TryConfirmMonetaryRecallWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'ConfirmMonetaryRecall ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'DeliverMonetaryRecall ' \ + + 'CheckSourceDebit CheckDestinationCredit ' + sequence_list.addSequenceString(sequence_string) + # play the sequence + sequence_list.play(self) + +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingMonetaryRecall)) + return suite diff --git a/product/ERP5Banking/tests/testERP5BankingMoneyDepositRendering.py b/product/ERP5Banking/tests/testERP5BankingMoneyDepositRendering.py new file mode 100644 index 0000000000000000000000000000000000000000..48194e85fc07abd5cf8de2523bece3f979a1a472 --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingMoneyDepositRendering.py @@ -0,0 +1,562 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Contributors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin +from zLOG import LOG + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingMoneyDepositRendering(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Money Deposit Rendering + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a money deposit rendering + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingMoneyDepositRendering" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_money_deposit_rendering-0.1.bt5' # erp5_banking_cash contains all method for money deposit rendering + ) + + def getMoneyDepositRenderingModule(self): + """ + Return the Cash Transer Module + """ + return getattr(self.getPortal(), 'money_deposit_rendering_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the cahs transfer module + self.money_deposit_rendering_module = self.getMoneyDepositRenderingModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.piece_200, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_200} + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + self.gros_versement = self.paris.surface.gros_versement.guichet_1.encaisse_des_billets_et_monnaies + self.auxiliaire = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies + self.createCashInventory(source=None, destination=self.gros_versement, currency=self.currency_1, + line_list=line_list) + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that MoneyDepositRendering Module was created + self.assertEqual(self.money_deposit_rendering_module.getPortalType(), 'Money Deposit Rendering Module') + # check money deposit rendering module is empty + self.assertEqual(len(self.money_deposit_rendering_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in auxiliaire + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in auxiliaire + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (auxiliaire) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (gros_versement) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCreateMoneyDepositRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Create a money deposit rendering document and check it + """ + # Money deposit rendering has auxiliaire for source, gros_versement for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + + LOG('money_deposit_rendering_module.showDict()',0,self.money_deposit_rendering_module.showDict()) + self.money_deposit_rendering = self.money_deposit_rendering_module.newContent(id='money_deposit_rendering_1', portal_type='Money Deposit Rendering', source_value=self.gros_versement, source_total_asset_price=52400.0) + # execute tic + self.stepTic() + # check we have only one money deposit rendering + self.assertEqual(len(self.money_deposit_rendering_module.objectValues()), 1) + # get the money deposit rendering document + self.money_deposit_rendering = getattr(self.money_deposit_rendering_module, 'money_deposit_rendering_1') + # check its portal type + self.assertEqual(self.money_deposit_rendering.getPortalType(), 'Money Deposit Rendering') + # check that its source is auxiliaire + self.assertEqual(self.money_deposit_rendering.getSource(), 'site/testsite/paris/surface/gros_versement/guichet_1/encaisse_des_billets_et_monnaies') + # check that its destination is gros_versement + #self.assertEqual(self.money_deposit_rendering.getDestination(), 'site/testsite/paris/surface/caisse_courante/encaisse_des_billets_et_monnaies') + + + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the money deposit rendering line 1 with banknotes of 10000 and check it has been well created + """ + # create the money deposit rendering line + self.addCashLineToDelivery(self.money_deposit_rendering, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.money_deposit_rendering.objectValues()), 1) + # get the money deposit rendering line + self.valid_line_1 = getattr(self.money_deposit_rendering, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is auxiliaire + self.assertEqual(cell.getSourceValue(), self.gros_versement) + # check the destination vault is gros_versement + #self.assertEqual(cell.getDestinationValue(), self.auxiliaire) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of money deposit rendering line 1 + """ + # Check number of lines + self.assertEqual(len(self.money_deposit_rendering.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.money_deposit_rendering.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.money_deposit_rendering.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the money deposit rendering line 2 wiht coins of 200 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.money_deposit_rendering, 'valid_line_2', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.money_deposit_rendering.objectValues()), 2) + # get the second money deposit rendering line + self.valid_line_2 = getattr(self.money_deposit_rendering, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is coin of 200 + self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) + # check the value of coin + self.assertEqual(self.valid_line_2.getPrice(), 200.0) + # check the unit of coin + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for coin for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 5.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for coin for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 7.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid money deposit rendering line and + check the total with the invalid money deposit rendering line + """ + # create a line in which quanity of banknotes of 5000 is higher that quantity available at source + # here create a line with 24 (11+13) banknotes of 500 although the vault auxiliaire has no banknote of 5000 + self.addCashLineToDelivery(self.money_deposit_rendering, 'invalid_line', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # Check number of money deposit rendering lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.money_deposit_rendering.objectValues()), 3) + # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 + self.assertEqual(self.money_deposit_rendering.getTotalQuantity(), 5.0 + 12.0 + 24) + # chect the total price + self.assertEqual(self.money_deposit_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) + + + def stepTryConfirmMoneyDepositRenderingWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the money deposit rendering with a bad money deposit rendering line and + check the try of confirm the money deposit rendering with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.money_deposit_rendering.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.money_deposit_rendering, 'confirm_action', wf_id='money_deposit_rendering_workflow') + # execute tic + self.stepTic() + # get state of the money deposit rendering + state = self.money_deposit_rendering.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.money_deposit_rendering, name='history', wf_id='money_deposit_rendering_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 4) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + + + def stepTryOrderMoneyDepositRenderingWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the money deposit rendering with a bad money deposit rendering line and + check the try of confirm the money deposit rendering with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.money_deposit_rendering.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.money_deposit_rendering, 'order_action', wf_id='money_deposit_rendering_workflow') + # execute tic + self.stepTic() + # get state of the money deposit rendering + state = self.money_deposit_rendering.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.money_deposit_rendering, name='history', wf_id='money_deposit_rendering_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid money deposit rendering line previously create + """ + self.money_deposit_rendering.deleteContent('invalid_line') + + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two money deposit rendering lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.money_deposit_rendering.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 + self.assertEqual(self.money_deposit_rendering.getTotalQuantity(), 5.0 + 12.0) + # check the total price + self.assertEqual(self.money_deposit_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) + + + def stepConfirmMoneyDepositRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the money deposit rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.money_deposit_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.money_deposit_rendering, 'confirm_action', wf_id='money_deposit_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.money_deposit_rendering.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.money_deposit_rendering, name='history', wf_id='money_deposit_rendering_workflow') + # check len of workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + def stepOrderMoneyDepositRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the money deposit rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.money_deposit_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.money_deposit_rendering, 'order_action', wf_id='money_deposit_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.money_deposit_rendering.getSimulationState() + # check state is ordered + self.assertEqual(state, 'ordered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.money_deposit_rendering, name='history', wf_id='money_deposit_rendering_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault auxiliaire is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault gros_versement is right after confirm and before deliver + """ + + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepDeliverMoneyDepositRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the money deposit rendering with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.money_deposit_rendering, 'deliver_action', wf_id='money_deposit_rendering_workflow') + # execute tic + self.stepTic() + # get state of money deposit rendering + state = self.money_deposit_rendering.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.money_deposit_rendering, name='history', wf_id='money_deposit_rendering_workflow') + # check len of len workflow history is 8 + self.assertEqual(len(workflow_history), 8) + + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault auxiliaire) after deliver of the money deposit rendering + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.gros_versement.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault gros_versement) after deliver of the money deposit rendering + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + ################################## + ## Tests + ################################## + + def test_01_ERP5BankingMoneyDepositRendering(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ + + 'CreateMoneyDepositRendering ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource CheckDestination ' \ + + 'CreateInvalidLine ' \ + + 'TryOrderMoneyDepositRenderingWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'OrderMoneyDepositRendering ' \ + + 'Tic CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'ConfirmMoneyDepositRendering ' \ + + 'DeliverMoneyDepositRendering ' \ + + 'CheckSourceDebit CheckDestinationCredit ' + sequence_list.addSequenceString(sequence_string) + # play the sequence + sequence_list.play(self) + +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingMoneyDepositRendering)) + return suite diff --git a/product/ERP5Banking/tests/testERP5BankingUsualCashRendering.py b/product/ERP5Banking/tests/testERP5BankingUsualCashRendering.py new file mode 100644 index 0000000000000000000000000000000000000000..021eec587f3bea8070f560725474068308f64249 --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingUsualCashRendering.py @@ -0,0 +1,637 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Concaisse_courantebutors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 rediscaisse_courantebute 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 discaisse_courantebuted 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingUsualCashRendering(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Usual Cash Rendering + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a vault transfer + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "plan_action" transition + - check that the new state is planned + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "order_action" transition + - check that the new state is ordered + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingUsualCashRendering" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_usual_cash_rendering-0.1.bt5' # erp5_banking_cash contains all method for vault transfer + ) + + def getUsualCashRenderingModule(self): + """ + Return the Vault Transer Module + """ + return getattr(self.getPortal(), 'usual_cash_rendering_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the cahs transfer module + self.usual_cash_rendering_module = self.getUsualCashRenderingModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.piece_200, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_200} + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + + self.caisse_courante = self.paris.surface.caisse_courante.encaisse_des_billets_et_monnaies + self.auxiliaire = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies + self.createCashInventory(source=None, destination=self.caisse_courante, currency=self.currency_1, + line_list=line_list) + + + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that UsualCashRendering Module was created + self.assertEqual(self.usual_cash_rendering_module.getPortalType(), 'Usual Cash Rendering Module') + # check vault transfer module is empty + self.assertEqual(len(self.usual_cash_rendering_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in caisse_courante + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in caisse_courante + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (caisse_courante) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (caisse_courante) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCreateUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Create a vault transfer document and check it + """ + # Usual Cash Rendering has caisse_courante (Gros versment) for source, caisse_courante for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + + + self.usual_cash_rendering = self.usual_cash_rendering_module.newContent(id='usual_cash_rendering_1', + portal_type='Usual Cash Rendering', source=self.caisse_courante.getRelativeUrl(), + destination=self.auxiliaire.getRelativeUrl(), source_total_asset_price=52400.0) + # execute tic + self.stepTic() + # check we have only one vault transfer + self.assertEqual(len(self.usual_cash_rendering_module.objectValues()), 1) + # get the vault transfer document + self.usual_cash_rendering = getattr(self.usual_cash_rendering_module, 'usual_cash_rendering_1') + # check its portal type + self.assertEqual(self.usual_cash_rendering.getPortalType(), 'Usual Cash Rendering') + # check that its source is caisse_courante + self.assertEqual(self.usual_cash_rendering.getSource(), 'site/testsite/paris/surface/caisse_courante/encaisse_des_billets_et_monnaies') + # check that its destination is caisse auxiliaire + self.assertEqual(self.usual_cash_rendering.getDestination(), 'site/testsite/paris/caveau/auxiliaire/encaisse_des_billets_et_monnaies') + + + + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the vault transfer line 1 with banknotes of 10000 and check it has been well created + """ + # create the vault transfer line + self.addCashLineToDelivery(self.usual_cash_rendering, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.usual_cash_rendering.objectValues()), 1) + # get the vault transfer line + self.valid_line_1 = getattr(self.usual_cash_rendering, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is caisse_courante + self.assertEqual(cell.getSourceValue(), self.caisse_courante) + # check the destination vault is caisse_courante + self.assertEqual(cell.getDestinationValue(), self.auxiliaire) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + + + + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of vault transfer line 1 + """ + # Check number of lines + self.assertEqual(len(self.usual_cash_rendering.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.usual_cash_rendering.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.usual_cash_rendering.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the vault transfer line 2 wiht coins of 200 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.usual_cash_rendering, 'valid_line_2', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.usual_cash_rendering.objectValues()), 2) + # get the second vault transfer line + self.valid_line_2 = getattr(self.usual_cash_rendering, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is coin of 200 + self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) + # check the value of coin + self.assertEqual(self.valid_line_2.getPrice(), 200.0) + # check the unit of coin + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for coin for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 5.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for coin for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 7.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid vault transfer line and + check the total with the invalid vault transfer line + """ + # create a line in which quanity of banknotes of 5000 is higher that quantity available at source + # here create a line with 24 (11+13) banknotes of 500 although the vault caisse_courante has no banknote of 5000 + self.addCashLineToDelivery(self.usual_cash_rendering, 'invalid_line', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # Check number of vault transfer lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.usual_cash_rendering.objectValues()), 3) + # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 + self.assertEqual(self.usual_cash_rendering.getTotalQuantity(), 5.0 + 12.0 + 24) + # chect the total price + self.assertEqual(self.usual_cash_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) + + + def stepTryConfirmUsualCashRenderingWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the usual_cash_rendering with a bad usual_cash_rendering line and + check the try of confirm the usual_cash_rendering with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.usual_cash_rendering.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.usual_cash_rendering, 'confirm_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state of the usual_cash_rendering + state = self.usual_cash_rendering.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + def stepTryPlanUsualCashRenderingWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to plan the usual_cash_rendering with a bad usual_cash_rendering line and + check the try of confirm the usual_cash_rendering with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.usual_cash_rendering.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "plan_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.usual_cash_rendering, 'plan_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state of the usual_cash_rendering + state = self.usual_cash_rendering.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid usual_cash_rendering line previously create + """ + self.usual_cash_rendering.deleteContent('invalid_line') + + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two usual_cash_rendering lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.usual_cash_rendering.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 + self.assertEqual(self.usual_cash_rendering.getTotalQuantity(), 5.0 + 12.0) + # check the total price + self.assertEqual(self.usual_cash_rendering.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) + + + def stepConfirmUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the usual_cash_rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.usual_cash_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'confirm_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.usual_cash_rendering.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of workflow history is 8 + self.assertEqual(len(workflow_history), 8) + + + def stepPlanUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the usual_cash_rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.usual_cash_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'plan_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.usual_cash_rendering.getSimulationState() + # check state is planned + self.assertEqual(state, 'planned') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + def stepOrderUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the usual_cash_rendering and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.usual_cash_rendering.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'order_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state + state = self.usual_cash_rendering.getSimulationState() + # check state is ordered + self.assertEqual(state, 'ordered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 6) + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault caisse_courante is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + + + + def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault caisse_courante is right after confirm and before deliver + """ + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepDeliverUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the usual_cash_rendering with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'deliver_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state of usual_cash_rendering + state = self.usual_cash_rendering.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of len workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + def stepDeliverUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the usual_cash_rendering with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'deliver_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state of usual_cash_rendering + state = self.usual_cash_rendering.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of len workflow history is 10 + self.assertEqual(len(workflow_history), 10) + + def stepOrderToDeliverUsualCashRendering(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the usual_cash_rendering with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + + self.workflow_tool.doActionFor(self.usual_cash_rendering, 'order_to_deliver_action', wf_id='usual_cash_rendering_workflow') + # execute tic + self.stepTic() + # get state of usual_cash_rendering + state = self.usual_cash_rendering.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.usual_cash_rendering, name='history', wf_id='usual_cash_rendering_workflow') + # check len of len workflow history is 10 + self.assertEqual(len(workflow_history), 8) + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault caisse_courante) after deliver of the usual_cash_rendering + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + + def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault caisse_courante) after deliver of the usual_cash_rendering + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + + def test_01_ERP5BankingUsualCashRendering(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ + + 'CreateUsualCashRendering ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource CheckDestination ' \ + + 'CreateInvalidLine ' \ + + 'TryPlanUsualCashRenderingWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'PlanUsualCashRendering ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'OrderUsualCashRendering ' \ + + 'ConfirmUsualCashRendering ' \ + + 'DeliverUsualCashRendering ' \ + + 'CheckSourceDebit CheckDestinationCredit ' + + sequence_list.addSequenceString(sequence_string) + # play the sequence + sequence_list.play(self) +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingUsualCashRendering)) + return suite diff --git a/product/ERP5Banking/tests/testERP5BankingVaultTransfer.py b/product/ERP5Banking/tests/testERP5BankingVaultTransfer.py new file mode 100644 index 0000000000000000000000000000000000000000..9cf7f1d30828a29e009b1a35785ba269525f03a9 --- /dev/null +++ b/product/ERP5Banking/tests/testERP5BankingVaultTransfer.py @@ -0,0 +1,798 @@ +############################################################################## +# +# Copyright (c) 2005-2006 Nexedi SARL and Concaisse_courantebutors. All Rights Reserved. +# Alexandre Boeglin <alex_AT_nexedi_DOT_com> +# Kevin Deldycke <kevin_AT_nexedi_DOT_com> +# Aurelien Calonne <aurel@nexedi.com> +# +# 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 rediscaisse_courantebute 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 discaisse_courantebuted 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 requested python module +import os +from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase +from Products.ERP5Type.tests.Sequence import SequenceList +from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed +from Testing.ZopeTestCase.PortalTestCase import PortalTestCase +from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin + +# Needed in order to have a log file inside the current folder +os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log') +# Define the level of log we want, here is all +os.environ['EVENT_LOG_SEVERITY'] = '-300' + +# Define how to launch the script if we don't use runUnitTest script +if __name__ == '__main__': + execfile(os.path.join(sys.path[0], 'framework.py')) + + +class TestERP5BankingVaultTransfer(TestERP5BankingMixin, ERP5TypeTestCase): + """ + This class is a unit test to check the module of Vault Transfer + + Here are the following step that will be done in the test : + + - before the test, we need to create some movements that will put resources in the source + + - create a vault transfer + - check it has been created correctly + - check source and destination (current == future) + + - create a "Note Line" (billetage) + - check it has been created correctly + - check the total amount + + - create a second Line + - check it has been created correctly + - check the total amount + + - create an invalid Line (quantity > available at source) + - check that the system behaves correctly + + - pass "plan_action" transition + - check that the new state is planned + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "order_action" transition + - check that the new state is ordered + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + + - pass "confirm_action" transition + - check that the new state is confirmed + - check that the source has been debited correctly (current < future) + - check amount, lines, ... + + - pass "deliver_action" transition + - check that the new state is delivered + - check that the destination has been credited correctly (current == future) + + """ + + login = PortalTestCase.login + + # pseudo constants + RUN_ALL_TEST = 1 # we want to run all test + QUIET = 0 # we don't want the test to be quiet + + def getTitle(self): + """ + Return the title of the test + """ + return "ERP5BankingVaultTransfer" + + + def getBusinessTemplateList(self): + """ + Return the list of business templates we need to run the test. + This method is called during the initialization of the unit test by + the unit test framework in order to know which business templates + need to be installed to run the test on. + """ + return ('erp5_base' + , 'erp5_trade' + , 'erp5_accounting' + , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking + , 'erp5_banking_inventory' + , 'erp5_banking_vault_transfer-0.1.bt5' # erp5_banking_cash contains all method for vault transfer + ) + + def getVaultTransferModule(self): + """ + Return the Vault Transer Module + """ + return getattr(self.getPortal(), 'vault_transfer_module', None) + + + def afterSetUp(self): + """ + Method called before the launch of the test to initialize some data + """ + # Set some variables : + self.initDefaultVariable() + # the cahs transfer module + self.vault_transfer_module = self.getVaultTransferModule() + + self.createManagerAndLogin() + + # create categories + self.createFunctionGroupSiteCategory() + + # create resources + self.createBanknotesAndCoins() + + # Before the test, we need to input the inventory + + inventory_dict_line_1 = {'id' : 'inventory_line_1', + 'resource': self.billet_10000, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_10000} + + inventory_dict_line_2 = {'id' : 'inventory_line_2', + 'resource': self.piece_200, + 'variation_id': ('emission_letter', 'cash_status', 'variation'), + 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list, + 'quantity': self.quantity_200} + + line_list = [inventory_dict_line_1, inventory_dict_line_2] + self.usual_cash = self.paris.caveau.reserve.encaisse_des_billets_et_monnaies + self.caisse_courante = self.paris.surface.caisse_courante.encaisse_des_billets_et_monnaies + self.auxiliaire = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies + self.createCashInventory(source=None, destination=self.usual_cash, currency=self.currency_1, + line_list=line_list) + + self.createCashInventory(source=None, destination=self.auxiliaire, currency=self.currency_1, + line_list=line_list) + self.salle_tri = self.paris.surface.salle_tri.encaisse_des_billets_et_monnaies + + + def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): + """ + Check that all the objects we created in afterSetUp or + that were added by the business template and that we rely + on are really here. + """ + self.checkResourceCreated() + # check that VaultTransfer Module was created + self.assertEqual(self.vault_transfer_module.getPortalType(), 'Vault Transfer Module') + # check vault transfer module is empty + self.assertEqual(len(self.vault_transfer_module.objectValues()), 0) + + + def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + + def stepCheckInitialInventoryForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check the initial inventory before any operations + """ + self.simulation_tool = self.getSimulationTool() + # check we have 5 banknotes of 10000 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 in usual_cash + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (usual_cash) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepCheckSourceForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in source vault (usual_cash) before a confirm + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (caisse_courante) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCheckDestinationForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory in destination vault (caisse_courante) before confirm + """ + # check we don't have banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we don't have coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCreateVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Create a vault transfer document and check it + """ + # Vault Transfer has usual_cash (Gros versment) for source, caisse_courante for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + + + self.vault_transfer = self.vault_transfer_module.newContent(id='vault_transfer_1', + portal_type='Vault Transfer', source=self.usual_cash.getRelativeUrl(), + destination=self.caisse_courante.getRelativeUrl(), source_total_asset_price=52400.0) + # execute tic + self.stepTic() + # check we have only one vault transfer + self.assertEqual(len(self.vault_transfer_module.objectValues()), 1) + # get the vault transfer document + self.vault_transfer = getattr(self.vault_transfer_module, 'vault_transfer_1') + # check its portal type + self.assertEqual(self.vault_transfer.getPortalType(), 'Vault Transfer') + # check that its source is usual_cash + self.assertEqual(self.vault_transfer.getSource(), 'site/testsite/paris/caveau/reserve/encaisse_des_billets_et_monnaies') + # check that its destination is caisse_courante + self.assertEqual(self.vault_transfer.getDestination(), 'site/testsite/paris/surface/caisse_courante/encaisse_des_billets_et_monnaies') + + + def stepCreateVaultTransferForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Create a vault transfer document and check it + """ + # Vault Transfer has usual_cash (Gros versment) for source, caisse_courante for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 ) + self.vault_transfer = self.vault_transfer_module.newContent(id='vault_transfer_1', portal_type='Vault Transfer', source_value=self.auxiliaire, destination_value=self.salle_tri, source_total_asset_price=52400.0) + # execute tic + self.stepTic() + # check we have only one vault transfer + self.assertEqual(len(self.vault_transfer_module.objectValues()), 1) + # get the vault transfer document + self.vault_transfer = getattr(self.vault_transfer_module, 'vault_transfer_1') + # check its portal type + self.assertEqual(self.vault_transfer.getPortalType(), 'Vault Transfer') + # check that its source is usual_cash + self.assertEqual(self.vault_transfer.getSource(), 'site/testsite/paris/caveau/auxiliaire/encaisse_des_billets_et_monnaies') + # check that its destination is caisse_courante + self.assertEqual(self.vault_transfer.getDestination(), 'site/testsite/paris/surface/salle_tri/encaisse_des_billets_et_monnaies') + + def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the vault transfer line 1 with banknotes of 10000 and check it has been well created + """ + # create the vault transfer line + self.addCashLineToDelivery(self.vault_transfer, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.vault_transfer.objectValues()), 1) + # get the vault transfer line + self.valid_line_1 = getattr(self.vault_transfer, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is usual_cash + self.assertEqual(cell.getSourceValue(), self.usual_cash) + # check the destination vault is caisse_courante + self.assertEqual(cell.getDestinationValue(), self.caisse_courante) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + + + def stepCreateValidLineForTri1(self, sequence=None, sequence_list=None, **kwd): + """ + Create the vault transfer line 1 with banknotes of 10000 and check it has been well created + """ + # create the vault transfer line + self.addCashLineToDelivery(self.vault_transfer, 'valid_line_1', 'Cash Delivery Line', self.billet_10000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_10000) + # execute tic + self.stepTic() + # check there is only one line created + self.assertEqual(len(self.vault_transfer.objectValues()), 1) + # get the vault transfer line + self.valid_line_1 = getattr(self.vault_transfer, 'valid_line_1') + # check its portal type + self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Delivery Line') + # check the resource is banknotes of 10000 + self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000) + # chek the value of the banknote + self.assertEqual(self.valid_line_1.getPrice(), 10000.0) + # check the unit of banknote + self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_1.objectValues()), 2) + # now check for each variation (years 1992 and 2003) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') + # chek portal types + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + # check the banknote of the cell is banknote of 10000 + self.assertEqual(cell.getResourceValue(), self.billet_10000) + # check the source vault is usual_cash + self.assertEqual(cell.getSourceValue(), self.auxiliaire) + # check the destination vault is caisse_courante + self.assertEqual(cell.getDestinationValue(), self.salle_tri) + if cell.getId() == 'movement_0_0_0': + # check the quantity of banknote for year 1992 is 2 + self.assertEqual(cell.getQuantity(), 2.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity of banknote for year 2003 is 3 + self.assertEqual(cell.getQuantity(), 3.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the amount after the creation of vault transfer line 1 + """ + # Check number of lines + self.assertEqual(len(self.vault_transfer.objectValues()), 1) + # Check quantity of banknotes (2 for 1992 and 3 for 2003) + self.assertEqual(self.vault_transfer.getTotalQuantity(), 5.0) + # Check the total price + self.assertEqual(self.vault_transfer.getTotalPrice(), 10000 * 5.0) + + + def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd): + """ + Create the vault transfer line 2 wiht coins of 200 and check it has been well created + """ + # create the line + self.addCashLineToDelivery(self.vault_transfer, 'valid_line_2', 'Cash Delivery Line', self.piece_200, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_200) + # execute tic + self.stepTic() + # check the number of lines (line1 + line2) + self.assertEqual(len(self.vault_transfer.objectValues()), 2) + # get the second vault transfer line + self.valid_line_2 = getattr(self.vault_transfer, 'valid_line_2') + # check portal types + self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Delivery Line') + # check the resource is coin of 200 + self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) + # check the value of coin + self.assertEqual(self.valid_line_2.getPrice(), 200.0) + # check the unit of coin + self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit') + # check we have two delivery cells: (one for year 1992 and one for 2003) + self.assertEqual(len(self.valid_line_2.objectValues()), 2) + for variation in self.variation_list: + # get the delivery cell + cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid') + # check the portal type + self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') + if cell.getId() == 'movement_0_0_0': + # check the quantity for coin for year 1992 is 5 + self.assertEqual(cell.getQuantity(), 5.0) + elif cell.getId() == 'movement_0_1_0': + # check the quantity for coin for year 2003 is 7 + self.assertEqual(cell.getQuantity(), 7.0) + else: + self.fail('Wrong cell created : %s' % cell.getId()) + + + def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Create an invalid vault transfer line and + check the total with the invalid vault transfer line + """ + # create a line in which quanity of banknotes of 5000 is higher that quantity available at source + # here create a line with 24 (11+13) banknotes of 500 although the vault usual_cash has no banknote of 5000 + self.addCashLineToDelivery(self.vault_transfer, 'invalid_line', 'Cash Delivery Line', self.billet_5000, + ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, + self.quantity_5000) + # execute tic + self.stepTic() + # Check number of vault transfer lines (line1 + line2 +invalid_line) + self.assertEqual(len(self.vault_transfer.objectValues()), 3) + # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 + self.assertEqual(self.vault_transfer.getTotalQuantity(), 5.0 + 12.0 + 24) + # chect the total price + self.assertEqual(self.vault_transfer.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) + + + def stepTryConfirmVaultTransferWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to confirm the vault_transfer with a bad vault_transfer line and + check the try of confirm the vault_transfer with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.vault_transfer.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.vault_transfer, 'confirm_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state of the vault_transfer + state = self.vault_transfer.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + + def stepTryPlanVaultTransferWithBadInventory(self, sequence=None, sequence_list=None, **kwd): + """ + Try to plan the vault_transfer with a bad vault_transfer line and + check the try of confirm the vault_transfer with the invalid line has failed + """ + # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) + self.vault_transfer.setSourceTotalAssetPrice('172400.0') + # try to do the workflow action "plan_action', cath the exception ValidationFailed raised by workflow transition + self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.vault_transfer, 'plan_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state of the vault_transfer + state = self.vault_transfer.getSimulationState() + # check the state is draft + self.assertEqual(state, 'draft') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check its len is 2 + self.assertEqual(len(workflow_history), 2) + # check we get an "Insufficient balance" message in the workflow history because of the invalid line + msg = workflow_history[-1]['error_message'] + self.assertEqual('Insufficient Balance.', "%s" %(msg,)) + + def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid vault_transfer line previously create + """ + self.vault_transfer.deleteContent('invalid_line') + + + def stepDelVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Delete the invalid vault_transfer line previously create + """ + self.vault_transfer_module.deleteContent('vault_transfer_1') + + def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): + """ + Check the total after the creation of the two vault_transfer lines + """ + # Check number of lines (line1 + line2) + self.assertEqual(len(self.vault_transfer.objectValues()), 2) + # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 + self.assertEqual(self.vault_transfer.getTotalQuantity(), 5.0 + 12.0) + # check the total price + self.assertEqual(self.vault_transfer.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) + + + def stepConfirmVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the vault_transfer and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.vault_transfer.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.vault_transfer, 'confirm_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state + state = self.vault_transfer.getSimulationState() + # check state is confirmed + self.assertEqual(state, 'confirmed') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of workflow history is 8 + self.assertEqual(len(workflow_history), 8) + + + def stepPlanVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the vault_transfer and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.vault_transfer.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.vault_transfer, 'plan_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state + state = self.vault_transfer.getSimulationState() + # check state is planned + self.assertEqual(state, 'planned') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 4) + + def stepOrderVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Confirm the vault_transfer and check it + """ + # fix amount (10000 * 5.0 + 200 * 12.0) + self.vault_transfer.setSourceTotalAssetPrice('52400.0') + # do the Workflow action + self.workflow_tool.doActionFor(self.vault_transfer, 'order_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state + state = self.vault_transfer.getSimulationState() + # check state is ordered + self.assertEqual(state, 'ordered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of workflow history is 4 + self.assertEqual(len(workflow_history), 6) + + def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault usual_cash is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCheckSourceDebitPlannedForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault usual_cash is right after confirm and before deliver + """ + # check we have 5 banknotes of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we will have 0 banknote of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 12 coins of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + # check we will have 0 coin of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + + def stepCheckDestinationCreditPlannedForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault caisse_courante is right after confirm and before deliver + """ + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): + """ + Check that compution of inventory at vault caisse_courante is right after confirm and before deliver + """ + # check we have 0 banknote of 10000 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we will have 5 banknotes of 10000 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 0 coin of 200 currently + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + # check we will have 12 coins of 200 after deliver + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepDeliverVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the vault_transfer with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.vault_transfer, 'deliver_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state of vault_transfer + state = self.vault_transfer.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of len workflow history is 6 + self.assertEqual(len(workflow_history), 6) + + def stepConfirmToDeliverVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the vault_transfer with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + self.workflow_tool.doActionFor(self.vault_transfer, 'confirm_to_deliver_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state of vault_transfer + state = self.vault_transfer.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of len workflow history is 10 + self.assertEqual(len(workflow_history), 10) + + def stepOrderToDeliverVaultTransfer(self, sequence=None, sequence_list=None, **kwd): + """ + Deliver the vault_transfer with a good user + and check that the deliver of a cash tranfer have achieved + """ + # do the workflow transition "deliver_action" + print self.portal.acl_users.getUserById('chef_de_tri') + self.workflow_tool.doActionFor(self.vault_transfer, 'order_to_deliver_action', wf_id='vault_transfer_workflow') + # execute tic + self.stepTic() + # get state of vault_transfer + state = self.vault_transfer.getSimulationState() + # check that state is delivered + self.assertEqual(state, 'delivered') + # get workflow history + workflow_history = self.workflow_tool.getInfoFor(ob=self.vault_transfer, name='history', wf_id='vault_transfer_workflow') + # check len of len workflow history is 10 + self.assertEqual(len(workflow_history), 8) + + def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault usual_cash) after deliver of the vault_transfer + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.usual_cash.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCheckSourceDebitForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at source (vault usual_cash) after deliver of the vault_transfer + """ + # check we have 0 banknote of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) + # check we have 0 coin of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.auxiliaire.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) + + def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault caisse_courante) after deliver of the vault_transfer + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_courante.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + + def stepCheckDestinationCreditForTri(self, sequence=None, sequence_list=None, **kwd): + """ + Check inventory at destination (vault caisse_courante) after deliver of the vault_transfer + """ + # check we have 5 banknotes of 10000 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) + # check we have 12 coins of 200 + self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + self.assertEqual(self.simulation_tool.getFutureInventory(node=self.salle_tri.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) + ################################## + ## Tests + ################################## + + def test_01_ERP5BankingVaultTransfer(self, quiet=QUIET, run=RUN_ALL_TEST): + """ + Define the sequence of step that will be play + """ + if not run: return + sequence_list = SequenceList() + # define the sequence + sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ + + 'CreateVaultTransfer ' \ + + 'CreateValidLine1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSource CheckDestination ' \ + + 'CreateInvalidLine ' \ + + 'TryPlanVaultTransferWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'PlanVaultTransfer ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + + 'OrderVaultTransfer ' \ + + 'ConfirmVaultTransfer ' \ + + 'ConfirmToDeliverVaultTransfer ' \ + + 'CheckSourceDebit CheckDestinationCredit ' + + sequence_list.addSequenceString(sequence_string) + + another_sequence_string = 'Tic DelVaultTransfer Tic CheckObjects Tic CheckInitialInventoryForTri CheckSourceForTri CheckDestinationForTri ' \ + + 'CreateVaultTransferForTri ' \ + + 'CreateValidLineForTri1 CheckSubTotal ' \ + + 'CreateValidLine2 CheckTotal ' \ + + 'CheckSourceForTri CheckDestinationForTri ' \ + + 'CreateInvalidLine ' \ + + 'TryPlanVaultTransferWithBadInventory ' \ + + 'DelInvalidLine Tic CheckTotal ' \ + + 'PlanVaultTransfer ' \ + + 'CheckSourceDebitPlannedForTri CheckDestinationCreditPlannedForTri ' \ + + 'OrderVaultTransfer ' \ + + 'OrderToDeliverVaultTransfer ' \ + + 'CheckSourceDebitForTri CheckDestinationCreditForTri ' + + + + sequence_list.addSequenceString(another_sequence_string) + # play the sequence + sequence_list.play(self) +# define how we launch the unit test +if __name__ == '__main__': + framework() +else: + import unittest + def test_suite(): + suite = unittest.TestSuite() + suite.addTest(unittest.makeSuite(TestERP5BankingVaultTransfer)) + return suite