############################################################################## # # Copyright (c) 2006-2010 Nexedi SA and Contributors. All Rights Reserved. # 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.Sequence import SequenceList from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin from DateTime import DateTime # 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' class TestERP5BankingMutilatedBanknote(TestERP5BankingMixin): """ """ # 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 "ERP5BankingMutilatedBanknote" def getMutilatedBanknoteModule(self): """ Return the Cash Transer Module """ return getattr(self.getPortal(), 'mutilated_banknote_module', None) def afterSetUp(self): """ Method called before the launch of the test to initialize some data """ self.simulation_tool = self.getSimulationTool() # Set some variables : self.initDefaultVariable() # the cahs transfer module self.mutilated_banknote_module = self.getMutilatedBanknoteModule() self.createManagerAndLogin() # create categories self.createFunctionGroupSiteCategory(site_list = ['siege', 'paris']) # 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/not_defined', 'cash_status/valid') + self.variation_list, 'quantity': self.quantity_10000} line_list = [inventory_dict_line_1,] self.mutilated_banknote_vault = self.paris.surface.caisse_courante.billets_mutiles self.maculated_banknote_vault = self.paris.surface.caisse_courante.billets_macules self.counter = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.sortante self.hq_mutilated_banknote_vault = self.siege.surface.caisse_courante.billets_mutiles self.hq_maculated_banknote_vault = self.siege.surface.caisse_courante.billets_macules self.usual_vault = self.paris.surface.caisse_courante.encaisse_des_billets_et_monnaies self.hq_usual_vault = self.siege.surface.caisse_courante.encaisse_des_billets_et_monnaies self.hq_counter = self.siege.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.sortante self.counter_incomming = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.entrante self.hq_counter_incomming = self.siege.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.entrante self.createCashInventory(source=None, destination=self.counter, currency=self.currency_1, line_list=line_list) self.createCashInventory(source=None, destination=self.hq_counter, currency=self.currency_1, line_list=line_list) # 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_1 = self.organisation_module.newContent(id='baobab_org', portal_type='Organisation', function='banking', group='baobab', site='testsite/paris') self.organisation_2 = self.organisation_module.newContent(id='baobab_org_hq', portal_type='Organisation', function='banking', group='baobab', site='siege') # define the user user_dict = { 'super_user' : [['Manager'], self.organisation_1, 'banking/comptable', 'baobab', 'testsite/paris/surface/banque_interne/guichet_1'], 'hq_super_user' : [['Manager'], self.organisation_2, 'banking/comptable', 'baobab', 'siege/surface/banque_interne/guichet_1'] } # call method to create this user self.createERP5Users(user_dict) self.logout() self.login('super_user') self.future_date = DateTime(DateTime().Date()) + 4 self.openCounterDate(site=self.paris) self.openCounterDate(site=self.siege, id='counter_date_2') self.openCounterDate(site=self.paris, id='counter_date_3', date=self.future_date) self.openCounterDate(site=self.siege, id='counter_date_4', date=self.future_date) self.openCounter(site=self.paris.surface.banque_interne.guichet_1) self.openCounter(site=self.siege.surface.banque_interne.guichet_1, id='counter_2') 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 MutilatedBanknote Module was created self.assertEqual(self.mutilated_banknote_module.getPortalType(), 'Mutilated Banknote Module') # check cash transfer module is empty self.assertEqual(len(self.mutilated_banknote_module.objectValues()), 0) def stepCancelDocument(self, sequence=None, sequence_list=None, **kwd): """ Cancel document. """ self.workflow_tool.doActionFor(self.mutilated_banknote, 'cancel_action', wf_id='mutilated_banknote_workflow') self.assertEqual(self.mutilated_banknote.getSimulationState(), 'cancelled') def stepArchiveDocument(self, sequence=None, sequence_list=None, **kwd): """ Archive document. """ self.workflow_tool.doActionFor(self.mutilated_banknote, 'archive_action', wf_id='mutilated_banknote_workflow') self.assertEqual(self.mutilated_banknote.getSimulationState(), 'archived') def stepCancelHQDocument(self, sequence=None, sequence_list=None, **kwd): """ Cancel HQ document. """ self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'cancel_action', wf_id='mutilated_banknote_workflow') self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), 'cancelled') def stepDepositDocument(self, sequence=None, sequence_list=None, **kwd): """ Deposit document. """ self.workflow_tool.doActionFor(self.mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow') self.assertEqual(self.mutilated_banknote.getSimulationState(), 'depositied') def stepDepositHQDocument(self, sequence=None, sequence_list=None, **kwd): """ Deposit HQ document. """ self.hq_mutilated_banknote.setDestinationTotalAssetPrice(50000.0) self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), 'deposited') def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): """ Check the initial inventory before any operations """ # check we have 5 banknotes of 10000 in mutilated_banknote self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0) # mutilated banknote inventory contains no 10000 banknote self.checkBanknoteInventory(node_path=self.mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) # maculated banknote inventory contains no 10000 banknote self.checkBanknoteInventory(node_path=self.maculated_banknote_vault.getRelativeUrl(), quantity=0.0) # Nothing in counter's incomming self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0) # Nothing in HQ counter's incomming self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0) # Nothing in usual vault self.checkBanknoteInventory(node_path=self.usual_vault.getRelativeUrl(), quantity=0.0) def stepCreateMutilatedBanknote(self, sequence=None, sequence_list=None, **kwd): """ Create a mutilated banknote document and check it """ self.mutilated_banknote = self.mutilated_banknote_module.newContent( id='mutilated_banknote', portal_type='Mutilated Banknote', source_total_asset_price=0.0, destination_total_asset_price=0.0, description='test', deponent="user", destination_value=self.mutilated_banknote_vault, site_value=self.paris) self.stepTic() self.assertTrue(len(self.mutilated_banknote_module.objectValues()) != 0) self.assertEqual(self.mutilated_banknote.getPortalType(), 'Mutilated Banknote') self.assertEqual(self.mutilated_banknote.getSource(), 'site/testsite/paris/surface/banque_interne/guichet_1') self.assertEqual(self.mutilated_banknote.getSourceTrade(), 'site/testsite/paris') self.assertEqual(self.mutilated_banknote.getDestination(), self.mutilated_banknote_vault.getRelativeUrl()) # set source reference self.setDocumentSourceReference(self.mutilated_banknote) # check source reference self.assertNotEqual(self.mutilated_banknote.getSourceReference(), '') self.assertNotEqual(self.mutilated_banknote.getSourceReference(), None) # headquarter is used in order to know if the document will go to the # headquarter or not. sequence.edit(headquarter=0) def stepTryDraftWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to stop with no amount defined on the document """ self.assertEqual(len(self.mutilated_banknote.objectValues()), 0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepTryHQDraftWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to stop with no amount defined on the document """ self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepCreateIncomingLine(self, sequence=None, sequence_list=None, **kwd): """ Create the incoming mutilated banknote line with banknotes of 10000 and check it has been well created """ # create the line self.addCashLineToDelivery(self.mutilated_banknote, 'incoming_line', 'Incoming Mutilated Banknote Line', self.billet_10000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/mutilated') + self.variation_list, self.quantity_10000) self.stepTic() self.assertEqual(len(self.mutilated_banknote.objectValues()), 1) # get the line self.incoming_line = getattr(self.mutilated_banknote, 'incoming_line') self.assertEqual(self.incoming_line.getPortalType(), 'Incoming Mutilated Banknote Line') self.assertEqual(self.incoming_line.getResourceValue(), self.billet_10000) self.assertEqual(self.incoming_line.getPrice(), 10000.0) self.assertEqual(self.incoming_line.getQuantityUnit(), 'unit') # check we have two delivery cells: (one for year 1992 and one for 2003) self.assertEqual(len(self.incoming_line.objectValues()), 2) mutilated_banknote_destination = self.mutilated_banknote.getDestination() for variation in self.variation_list: cell = self.incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/mutilated') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getBaobabSourceValue(), None) self.assertEqual(cell.getBaobabDestination(), None) if cell.getId() == 'movement_0_0_0': self.assertEqual(cell.getQuantity(), 2.0) elif cell.getId() == 'movement_0_1_0': self.assertEqual(cell.getQuantity(), 3.0) else: self.fail('Wrong cell created : %s' % cell.getId()) def stepTryDraftWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to stop with no amount defined on the document """ self.assertEqual(self.mutilated_banknote.getSourceTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepTryHQDraftWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to stop with no amount defined on the document """ self.assertEqual(self.hq_mutilated_banknote.getSourceTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepDraftDocument(self, sequence=None, sequence_list=None, **kw): """ Draft mutilated banknote operation Also sets the received amount on the document. """ self.mutilated_banknote.setSourceTotalAssetPrice(50000.0) self.assertEqual(self.mutilated_banknote.getSourceTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.mutilated_banknote.getSimulationState(), "draft") def stepDraftHQDocument(self, sequence=None, sequence_list=None, **kw): """ Draft mutilated banknote operation Also set the original price of mutilated banknotes. """ self.hq_mutilated_banknote.setSourceTotalAssetPrice(50000.0) self.assertEqual(self.hq_mutilated_banknote.getSourceTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "draft") def stepStopDocument(self, sequence=None, sequence_list=None, **kw): """ Stop mutilated banknote operation """ self.workflow_tool.doActionFor(self.mutilated_banknote, 'stop_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.mutilated_banknote.getSimulationState(), "stopped") def stepCreateExchangedLine(self, sequence=None, sequence_list=None, **kw): """ """ # create an exchanged self.addCashLineToDelivery(self.mutilated_banknote, 'exchanged_line', 'Exchanged Mutilated Banknote Line', self.billet_10000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/cancelled') + self.variation_list, self.quantity_10000) self.stepTic() self.assertEqual(len(self.mutilated_banknote.objectValues()), 2) # get the line self.exchanged_line = getattr(self.mutilated_banknote, 'exchanged_line') self.assertEqual(self.exchanged_line.getPortalType(), 'Exchanged Mutilated Banknote Line') self.assertEqual(self.exchanged_line.getResourceValue(), self.billet_10000) self.assertEqual(self.exchanged_line.getPrice(), 10000.0) self.assertEqual(self.exchanged_line.getQuantityUnit(), 'unit') # check we have two delivery cells: (one for year 1992 and one for 2003) self.assertEqual(len(self.exchanged_line.objectValues()), 2) for variation in self.variation_list: cell = self.exchanged_line.getCell('emission_letter/not_defined', variation, 'cash_status/cancelled') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getBaobabSourceValue(), None) self.assertEqual(cell.getBaobabDestinationValue(), None) if cell.getId() == 'movement_0_0_0': self.assertEqual(cell.getQuantity(), 2.0) elif cell.getId() == 'movement_0_1_0': self.assertEqual(cell.getQuantity(), 3.0) else: self.fail('Wrong cell created : %s' % cell.getId()) def stepTryPlanWithExchangedLine(self, sequence=None, sequence_list=None, **kw): """ Try to plan with exchanged line defined """ self.assertEqual(len(self.mutilated_banknote.objectValues(portal_type='Exchanged Mutilated Banknote Line')), 1.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow') def stepPlanDocument(self, sequence=None, sequence_list=None, **kw): """ Plan mutilated banknote operation """ self.workflow_tool.doActionFor(self.mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.mutilated_banknote.getSimulationState(), "planned") def stepDelExchangedLine(self, sequence=None, sequence_list=None, **kwd): """ Delete the invalid cash transfer line previously create """ self.mutilated_banknote.deleteContent('exchanged_line') def stepDeliverDocument(self, sequence=None, sequence_list=None, **kw): """ Deliver mutilated banknote operation. Also sets the exchanged amount on the document. """ self.mutilated_banknote.setDestinationTotalAssetPrice(50000.0) self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.mutilated_banknote.getSimulationState(), "delivered") def stepDeliverHQDocument(self, sequence=None, sequence_list=None, **kw): """ Deliver mutilated banknote operation. Also sets the exchanged amount on the document. """ self.hq_mutilated_banknote.setDestinationTotalAssetPrice(50000.0) self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "delivered") def stepCheckFinalInventoryWithNoPayBack(self, sequence=None, sequence_list=None, **kwd): """ Check the final inventory when document got rejected without HQ request """ self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0) self.checkFinalInventory() stepCheckFinalInventoryWithNoPayBackAfterHQRequest = stepCheckFinalInventoryWithNoPayBack def stepClearMutilatedBanknoteModule(self, sequence=None, sequence_list=None, **kw): """ Remove all operations in module """ delattr(self, 'mutilated_banknote') self.mutilated_banknote_module.deleteContent('mutilated_banknote') def stepTryFinishWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to confirm with no line defined on the document """ self.assertEqual(len(self.mutilated_banknote.objectValues(portal_type="Exchanged Mutilated Banknote Line")), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') def stepTryFinishHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to confirm with no line defined on the document """ self.assertEqual(len(self.hq_mutilated_banknote.objectValues(portal_type="Exchanged Mutilated Banknote Line")), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') def stepTryDepositHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deposit with no line defined on the document """ self.assertEqual(len(self.hq_mutilated_banknote.objectValues(portal_type="Exchanged Mutilated Banknote Line")), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow') def stepTryFinishWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to confirm with no amount defined on the document """ self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') def stepTryFinishHQWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to confirm with no amount defined on the document """ self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') def stepTryDepositHQWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deposit with no amount defined on the document """ self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow') def stepFinishDocument(self, sequence=None, sequence_list=None, **kw): """ Finish mutilated banknote operation (send to counter) """ self.mutilated_banknote.setDestinationTotalAssetPrice(50000.0) self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.mutilated_banknote.getSimulationState(), "finished") def stepTryDeliverWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deliver with no outgoing line defined on the document """ self.assertEqual(len(self.mutilated_banknote.objectValues(portal_type="Outgoing Mutilated Banknote Line")), 0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') def stepTryDeliverWithWrongAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deliver with wrong amount defined on the document at state ordered """ self.mutilated_banknote.setDestinationTotalAssetPrice(4000.0) self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 4000.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') def stepTryDeliverHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deliver with no outgoing line defined on the document """ self.assertEqual(len(self.hq_mutilated_banknote.objectValues(portal_type="Outgoing Mutilated Banknote Line")), 0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') def stepTryDeliverHQWithWrongAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to deliver with wrong amount defined on the document at state ordered """ self.hq_mutilated_banknote.setDestinationTotalAssetPrice(4000.0) self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 4000.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deliver_action', wf_id='mutilated_banknote_workflow') def createOutgoingLine(self, mutilated_banknote): """ """ # create an exchanged self.addCashLineToDelivery(mutilated_banknote, 'outgoing_line', 'Outgoing Mutilated Banknote Line', self.billet_10000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/valid') + self.variation_list, self.quantity_10000) self.stepTic() # get the line self.outgoing_line = getattr(mutilated_banknote, 'outgoing_line') self.assertEqual(self.outgoing_line.getPortalType(), 'Outgoing Mutilated Banknote Line') self.assertEqual(self.outgoing_line.getResourceValue(), self.billet_10000) self.assertEqual(self.outgoing_line.getPrice(), 10000.0) self.assertEqual(self.outgoing_line.getQuantityUnit(), 'unit') # check we have two delivery cells: (one for year 1992 and one for 2003) self.assertEqual(len(self.outgoing_line.objectValues()), 2) for variation in self.variation_list: cell = self.outgoing_line.getCell('emission_letter/not_defined', variation, 'cash_status/valid') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getBaobabSource(), None) self.assertEqual(cell.getBaobabDestinationValue(), None) if cell.getId() == 'movement_0_0_0': self.assertEqual(cell.getQuantity(), 2.0) elif cell.getId() == 'movement_0_1_0': self.assertEqual(cell.getQuantity(), 3.0) else: self.fail('Wrong cell created : %s' % cell.getId()) def stepCreateOutgoingLine(self, sequence=None, sequence_list=None, **kw): """ """ self.createOutgoingLine(self.mutilated_banknote) def stepCreateHQOutgoingLine(self, sequence=None, sequence_list=None, **kw): """ """ self.createOutgoingLine(self.hq_mutilated_banknote) def stepCheckFinalInventoryWithPayBack(self, sequence=None, sequence_list=None, **kwd): self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=0.0, get_inventory_kw={'variation_text': '%cash_status/valid%'}) self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0) self.checkFinalInventory() def checkFinalInventory(self): self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=self.mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.maculated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.usual_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0) def stepCheckFinalInventoryWithPayBackAfterHQRequest(self, sequence=None, sequence_list=None, **kw): self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date - 1}) self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + 1}) self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date - 1}) self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date + 1}) for offset in (-1, 1): self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.usual_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.mutilated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.maculated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) # # Headquarter part # def stepHQLogin(self, sequence=None, sequence_list=None, **kw): """ Login as a headquarter user """ self.logout() self.login("hq_super_user") def stepHQLogout(self, sequence=None, sequence_list=None, **kw): """ Login as a headquarter user """ self.logout() self.login("super_user") def stepCheckHQInitialInventory(self, sequence=None, sequence_list=None, **kwd): """ Check the initial inventory before any operations """ # check we have 5 banknotes of 10000 in mutilated_banknote self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0) # mutilated banknote inventory contains no 10000 banknote self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) # maculated banknote inventory contains no 10000 banknote self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=0.0) # nothing in usual vault self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0) def stepCreateHQMutilatedBanknote(self, sequence=None, sequence_list=None, owner_assigned_counter='site/siege/surface/banque_interne/guichet_1', **kwd): """ Create a mutilated banknote document and check it """ self.hq_mutilated_banknote = self.mutilated_banknote_module.newContent(id='hq_mutilated_banknote', portal_type='Mutilated Banknote', source_total_asset_price=0.0, destination_total_asset_price=0.0, destination_value=self.hq_mutilated_banknote_vault, deponent="hq user", causality_value=getattr(self, 'mutilated_banknote', None), site_value=self.siege) self.hq_mutilated_banknote.edit(source_trade='site/testsite/paris') self.stepTic() self.assertTrue(len(self.mutilated_banknote_module.objectValues()) != 0) self.assertEqual(self.hq_mutilated_banknote.getPortalType(), 'Mutilated Banknote') self.assertEqual(self.hq_mutilated_banknote.getSource(), owner_assigned_counter) self.assertEqual(self.hq_mutilated_banknote.getSourceTrade(), 'site/testsite/paris') self.assertEqual(self.hq_mutilated_banknote.getDestination(), self.hq_mutilated_banknote_vault.getRelativeUrl()) # set source reference self.setDocumentSourceReference(self.hq_mutilated_banknote) # check source reference self.assertNotEqual(self.hq_mutilated_banknote.getSourceReference(), '') self.assertNotEqual(self.hq_mutilated_banknote.getSourceReference(), None) def stepTryDraftHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw): """ Try to plan with no amount defined on the document """ self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepCreateHQIncomingLine(self, sequence=None, sequence_list=None, **kwd): """ Create the incoming mutilated banknote line with banknotes of 10000 and check it has been well created """ # create the line self.addCashLineToDelivery(self.hq_mutilated_banknote, 'hq_incoming_line', 'Incoming Mutilated Banknote Line', self.billet_10000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/mutilated') + self.variation_list, self.quantity_10000) self.stepTic() self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 1) # get the line self.hq_incoming_line = getattr(self.hq_mutilated_banknote, 'hq_incoming_line') self.assertEqual(self.hq_incoming_line.getPortalType(), 'Incoming Mutilated Banknote Line') self.assertEqual(self.hq_incoming_line.getResourceValue(), self.billet_10000) self.assertEqual(self.hq_incoming_line.getPrice(), 10000.0) self.assertEqual(self.hq_incoming_line.getQuantityUnit(), 'unit') # check we have two delivery cells: (one for year 1992 and one for 2003) self.assertEqual(len(self.hq_incoming_line.objectValues()), 2) hq_mutilated_banknote_destination = self.hq_mutilated_banknote.getDestination() for variation in self.variation_list: cell = self.hq_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/mutilated') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getBaobabSourceValue(), None) self.assertEqual(cell.getBaobabDestination(), None) if cell.getId() == 'movement_0_0_0': self.assertEqual(cell.getQuantity(), 2.0) elif cell.getId() == 'movement_0_1_0': self.assertEqual(cell.getQuantity(), 3.0) else: self.fail('Wrong cell created : %s' % cell.getId()) def stepTryDraftHQWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw): """ Try to plan with no amount defined on the document """ self.assertEqual(self.hq_mutilated_banknote.getSourceTotalAssetPrice(), 0.0) self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow') def stepStopHQDocument(self, sequence=None, sequence_list=None, **kw): """ Plan mutilated banknote operation """ self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'stop_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "stopped") def stepTryPlanHQDocument(self, sequence=None, sequence_list=None, **kw): """ It must not be possible (ie, action not present) to plan when the document is initiated in HQ. """ self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow') def stepTryFinishHQDocument(self, sequence=None, sequence_list=None, **kw): """ It must not be possible (ie, action not present) to finish when the document is sent to HQ. """ self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') def stepFinishHQDocument(self, sequence=None, sequence_list=None, **kw): """ Finish mutilated banknote operation Also set the price to pay back to the customer. """ self.hq_mutilated_banknote.setDestinationTotalAssetPrice(50000.0) self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0) self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow') self.stepTic() self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "finished") sequence.edit(headquarter=1) def checkBanknoteInventory(self, node_path, quantity, get_inventory_kw=None): """ Check that node contains expected quantity of banknotes. """ if get_inventory_kw is None: get_inventory_kw = {} resource_path = self.billet_10000.getRelativeUrl() self.assertEqual(self.simulation_tool.getCurrentInventory(node=node_path, resource=resource_path, **get_inventory_kw), quantity) self.assertEqual(self.simulation_tool.getFutureInventory(node=node_path, resource=resource_path, **get_inventory_kw), quantity) def stepCheckHQMaculatedBanknoteInventory(self, sequence=None, sequence_list=None, **kwd): """ Check HQ maculated banknote inventory """ self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=5.0) def stepCheckHQFinalInventoryWithNoPayBack(self, sequence=None, sequence_list=None, **kwd): """ Check the initial inventory before any operations """ self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0) self.checkFinalInventory() def stepClearHQMutilatedBanknoteModule(self, sequence=None, sequence_list=None, **kw): """ Remove all operations in module """ delattr(self, 'hq_mutilated_banknote') self.mutilated_banknote_module.deleteContent('hq_mutilated_banknote') def stepCreateHQExchangedLine(self, sequence=None, sequence_list=None, **kw): """ """ # create an exchanged self.addCashLineToDelivery(self.hq_mutilated_banknote, 'hq_exchanged_line', 'Exchanged Mutilated Banknote Line', self.billet_10000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/cancelled') + self.variation_list, self.quantity_10000) self.stepTic() self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 2) # get the line self.hq_exchanged_line = getattr(self.hq_mutilated_banknote, 'hq_exchanged_line') self.assertEqual(self.hq_exchanged_line.getPortalType(), 'Exchanged Mutilated Banknote Line') self.assertEqual(self.hq_exchanged_line.getResourceValue(), self.billet_10000) self.assertEqual(self.hq_exchanged_line.getPrice(), 10000.0) self.assertEqual(self.hq_exchanged_line.getQuantityUnit(), 'unit') # check we have two delivery cells: (one for year 1992 and one for 2003) self.assertEqual(len(self.hq_exchanged_line.objectValues()), 2) for variation in self.variation_list: cell = self.hq_exchanged_line.getCell('emission_letter/not_defined', variation, 'cash_status/cancelled') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getBaobabSourceValue(), None) self.assertEqual(cell.getBaobabDestination(), None) if cell.getId() == 'movement_0_0_0': self.assertEqual(cell.getQuantity(), 2.0) elif cell.getId() == 'movement_0_1_0': self.assertEqual(cell.getQuantity(), 3.0) else: self.fail('Wrong cell created : %s' % cell.getId()) def stepCheckHQFinalInventoryWithPayBack(self, sequence=None, sequence_list=None, **kwd): """ Check the final inventory when the mutilated payment was approved by headquaters. """ self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date - 1}) self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date + 1}) for offset in (-1, 1): self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.mutilated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.maculated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=0.0, get_inventory_kw={'at_date': self.future_date + offset}) def stepCheckHQFinalInventoryWithHQPayBack(self, sequence=None, sequence_list=None, **kwd): self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.maculated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=self.hq_maculated_banknote_vault.getRelativeUrl(), quantity=0.0) def CheckInventoryWithIncommingBanknotes(self, node, hq_node): """ Check that mutilated banknotes transmites by agency are in the right stock place. """ self.checkBanknoteInventory(node_path=node.getRelativeUrl(), quantity=5.0) self.checkBanknoteInventory(node_path=hq_node.getRelativeUrl(), quantity=0.0) def stepCheckInventoryWithIncommingMutilatedBanknotes(self, sequence=None, sequence_list=None, **kwd): self.CheckInventoryWithIncommingBanknotes(self.mutilated_banknote_vault, self.hq_mutilated_banknote_vault) def stepCheckInventoryWithIncommingMaculatedBanknotes(self, sequence=None, sequence_list=None, **kwd): self.CheckInventoryWithIncommingBanknotes(self.maculated_banknote_vault, self.hq_maculated_banknote_vault) def CheckHQInventoryWithIncommingBanknotes(self, node, hq_node): """ Check that mutilated banknotes transmites by agency are in the right stock place. """ self.checkBanknoteInventory(node_path=node.getRelativeUrl(), quantity=0.0) self.checkBanknoteInventory(node_path=hq_node.getRelativeUrl(), quantity=5.0) def stepCheckHQInventoryWithIncommingMutilatedBanknotes(self, sequence=None, sequence_list=None, **kwd): self.CheckHQInventoryWithIncommingBanknotes(self.mutilated_banknote_vault, self.hq_mutilated_banknote_vault) def stepCheckHQInventoryWithIncommingMaculatedBanknotes(self, sequence=None, sequence_list=None, **kwd): self.CheckHQInventoryWithIncommingBanknotes(self.maculated_banknote_vault, self.hq_maculated_banknote_vault) def stepSetMaculatedState(self, sequence=None, sequence_list=None, **kwd): """ Inform that the banknotes are in a maculated state, not in a mutilated state. """ self.mutilated_banknote.setDestinationValue(self.maculated_banknote_vault) def stepSetHQMaculatedState(self, sequence=None, sequence_list=None, **kwd): """ Inform that the banknotes are in a maculated state, not in a mutilated state. """ self.hq_mutilated_banknote.setDestinationValue(self.hq_maculated_banknote_vault) def moveToFuture(self, document): """ Set document's stop date to self.future_date. """ document.setStopDate(self.future_date) def stepMoveToFuture(self, sequence=None, sequence_list=None, **kwd): self.moveToFuture(self.mutilated_banknote) def stepMoveHQToFuture(self, sequence=None, sequence_list=None, **kwd): self.moveToFuture(self.hq_mutilated_banknote) ################################## ## Tests ################################## def test_01_ERP5BankingMutilatedBanknote(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 1 : no payback, mutilated banknotes sequence_string_1 = 'Tic CheckObjects Tic CheckInitialInventory ' \ + 'CreateMutilatedBanknote Tic TryDraftWithNoLineDefined ' \ + 'CreateIncomingLine Tic TryDraftWithNoAmountDefined ' \ + 'DraftDocument Tic StopDocument Tic ' \ + 'CheckInventoryWithIncommingMutilatedBanknotes ' \ + 'CancelDocument Tic ' \ + 'CheckFinalInventoryWithNoPayBack ClearMutilatedBanknoteModule' # sequence 2 : pay back, maculated banknotes sequence_string_2 = 'Tic CheckObjects Tic CheckInitialInventory ' \ + 'CreateMutilatedBanknote SetMaculatedState Tic ' \ + 'CreateIncomingLine Tic ' \ + 'DraftDocument Tic StopDocument Tic ' \ + 'CheckInventoryWithIncommingMaculatedBanknotes ' \ + 'TryFinishWithNoLineDefined CreateExchangedLine Tic TryFinishWithNoAmountDefined FinishDocument Tic ' \ + 'TryDeliverWithNoLineDefined CreateOutgoingLine Tic TryDeliverWithWrongAmountDefined DeliverDocument Tic ' \ + 'CheckFinalInventoryWithPayBack ClearMutilatedBanknoteModule' # sequence 3 : ask headquarters then no payback, mutilated banknotes sequence_string_3 = 'Tic CheckObjects Tic CheckInitialInventory ' \ + 'CreateMutilatedBanknote Tic ' \ + 'CreateIncomingLine Tic ' \ + 'DraftDocument Tic StopDocument Tic ' \ + 'CheckInventoryWithIncommingMutilatedBanknotes ' \ + 'CreateExchangedLine Tic TryPlanWithExchangedLine DelExchangedLine Tic PlanDocument Tic ' \ + 'HQLogin ' \ + 'CheckHQInitialInventory ' \ + 'CreateHQMutilatedBanknote Tic '\ + 'TryDraftHQWithNoLineDefined Tic CreateHQIncomingLine Tic TryDraftHQWithNoAmountDefined DraftHQDocument Tic StopHQDocument Tic ' \ + 'CheckHQInventoryWithIncommingMutilatedBanknotes ' \ + 'TryPlanHQDocument ' \ + 'CancelHQDocument Tic ' \ + 'HQLogout ' \ + 'CheckHQFinalInventoryWithNoPayBack ' \ + 'ArchiveDocument Tic ' \ + 'CheckFinalInventoryWithNoPayBackAfterHQRequest ClearMutilatedBanknoteModule ClearHQMutilatedBanknoteModule' # sequence 4 : ask headquarters then payback, maculated banknotes sequence_string_4 = 'Tic CheckObjects Tic CheckInitialInventory ' \ + 'CreateMutilatedBanknote SetMaculatedState Tic ' \ + 'CreateIncomingLine Tic ' \ + 'DraftDocument Tic StopDocument Tic ' \ + 'PlanDocument Tic ' \ + 'HQLogin ' \ + 'CheckHQInitialInventory ' \ + 'CreateHQMutilatedBanknote SetHQMaculatedState Tic ' \ + 'CreateHQIncomingLine Tic DraftHQDocument Tic StopHQDocument Tic ' \ + 'MoveHQToFuture Tic ' \ + 'CheckHQInventoryWithIncommingMaculatedBanknotes ' \ + 'CheckHQMaculatedBanknoteInventory ' \ + 'TryDepositHQWithNoLineDefined CreateHQExchangedLine Tic TryDepositHQWithNoAmountDefined DepositHQDocument Tic ' \ + 'HQLogout ' \ + 'CheckHQFinalInventoryWithPayBack '\ + 'MoveToFuture Tic ' \ + 'CreateExchangedLine Tic FinishDocument Tic ' \ + 'CreateOutgoingLine Tic DeliverDocument Tic ' \ + 'CheckFinalInventoryWithPayBackAfterHQRequest ClearMutilatedBanknoteModule ClearHQMutilatedBanknoteModule' # sequence 5 : HQ, no payback, mutilated banknotes sequence_string_5 = 'Tic CheckObjects Tic CheckHQInitialInventory ' \ 'HQLogin ' \ 'CreateHQMutilatedBanknote Tic TryHQDraftWithNoLineDefined ' \ 'CreateHQIncomingLine Tic TryHQDraftWithNoAmountDefined ' \ 'DraftHQDocument Tic StopHQDocument Tic ' \ 'CheckHQInventoryWithIncommingMutilatedBanknotes ' \ 'CancelHQDocument Tic ' \ 'CheckHQFinalInventoryWithNoPayBack ClearHQMutilatedBanknoteModule' # sequence 6 : HQ, pay back, maculated banknotes sequence_string_6 = 'Tic CheckObjects Tic CheckHQInitialInventory ' \ 'HQLogin ' \ 'CreateHQMutilatedBanknote SetHQMaculatedState Tic ' \ 'CreateHQIncomingLine Tic ' \ 'DraftHQDocument Tic StopHQDocument Tic ' \ 'CheckHQInventoryWithIncommingMaculatedBanknotes ' \ 'TryFinishHQWithNoLineDefined CreateHQExchangedLine Tic TryFinishHQWithNoAmountDefined FinishHQDocument Tic ' \ 'TryDeliverHQWithNoLineDefined CreateHQOutgoingLine Tic TryDeliverHQWithWrongAmountDefined DeliverHQDocument Tic ' \ 'CheckHQFinalInventoryWithHQPayBack ClearHQMutilatedBanknoteModule' #sequence_list.addSequenceString(sequence_string_1) #sequence_list.addSequenceString(sequence_string_2) #sequence_list.addSequenceString(sequence_string_3) sequence_list.addSequenceString(sequence_string_4) sequence_list.addSequenceString(sequence_string_5) sequence_list.addSequenceString(sequence_string_6) # play the sequence sequence_list.play(self)