testERP5BankingMutilatedBanknote.py 52.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
##############################################################################
#
# Copyright (c) 2006 Nexedi SARL 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.ERP5TypeTestCase import ERP5TypeTestCase
from Products.ERP5Type.tests.Sequence import SequenceList
from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed
from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin
36
from DateTime import DateTime
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

# 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 TestERP5BankingMutilatedBanknote(TestERP5BankingMixin, ERP5TypeTestCase):
  """
  """

  # 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
    """
72
    self.simulation_tool = self.getSimulationTool()
73 74 75 76 77 78
    # Set some variables :
    self.initDefaultVariable()
    # the cahs transfer module
    self.mutilated_banknote_module = self.getMutilatedBanknoteModule()
    self.createManagerAndLogin()
    # create categories
79
    self.createFunctionGroupSiteCategory(site_list = ['siege', 'paris'])
80 81 82 83 84 85
    # 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'),
86
                             'variation_value': ('emission_letter/not_defined', 'cash_status/valid') + self.variation_list,
87 88 89 90
                             'quantity': self.quantity_10000}

    line_list = [inventory_dict_line_1,]
    self.mutilated_banknote_vault = self.paris.surface.caisse_courante.billets_mutiles
91
    self.maculated_banknote_vault = self.paris.surface.caisse_courante.billets_macules
92
    self.counter = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.sortante
93
    self.hq_mutilated_banknote_vault = self.siege.surface.caisse_courante.billets_mutiles
94
    self.hq_maculated_banknote_vault = self.siege.surface.caisse_courante.billets_macules
95 96 97 98 99 100
    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,
101
                             line_list=line_list)
102
    self.createCashInventory(source=None, destination=self.hq_counter, currency=self.currency_1,
103
                             line_list=line_list)
104 105 106 107
    # 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()
Aurel's avatar
Aurel committed
108
    self.organisation_1 = self.organisation_module.newContent(id='baobab_org', portal_type='Organisation',
109
                          function='banking', group='baobab',  site='testsite/paris')
Aurel's avatar
Aurel committed
110
    self.organisation_2 = self.organisation_module.newContent(id='baobab_org_hq', portal_type='Organisation',
111
                                                            function='banking', group='baobab',  site='siege')
112 113
    # define the user
    user_dict = {
Aurel's avatar
Aurel committed
114
        'super_user' : [['Manager'], self.organisation_1, 'banking/comptable', 'baobab', 'testsite/paris/surface/banque_interne/guichet_1'],
115
        'hq_super_user' : [['Manager'], self.organisation_2, 'banking/comptable', 'baobab', 'siege/surface/banque_interne/guichet_1']
116 117 118 119 120
      }
    # call method to create this user
    self.createERP5Users(user_dict)
    self.logout()
    self.login('super_user')
121
    self.future_date =  DateTime(DateTime().Date()) + 4
122 123
    self.openCounterDate(site=self.paris)
    self.openCounterDate(site=self.siege, id='counter_date_2')
124 125
    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)
126 127
    self.openCounter(site=self.paris.surface.banque_interne.guichet_1)
    self.openCounter(site=self.siege.surface.banque_interne.guichet_1, id='counter_2')
128 129 130 131 132 133 134 135 136 137 138 139 140

  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)

141 142 143 144 145 146 147
  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')

148 149 150 151 152 153 154
  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')

155 156 157 158 159 160 161 162
  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')


163
  def stepDepositDocument(self, sequence=None, sequence_list=None, **kwd):
164
    """
165
      Deposit document.
166
    """
167
    self.workflow_tool.doActionFor(self.mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow')
Vincent Pelletier's avatar
Vincent Pelletier committed
168
    self.assertEqual(self.mutilated_banknote.getSimulationState(), 'depositied')
169

170
  def stepDepositHQDocument(self, sequence=None, sequence_list=None, **kwd):
171
    """
172
      Deposit HQ document.
173
    """
174 175
    self.hq_mutilated_banknote.setDestinationTotalAssetPrice(50000.0)
    self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0)
176
    self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow')
177
    self.stepTic()
Vincent Pelletier's avatar
Vincent Pelletier committed
178
    self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), 'deposited')
179

180 181 182 183 184
  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
185
    self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0)
186 187 188 189
    # 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)
190
    # Nothing in counter's incomming
191
    self.checkBanknoteInventory(node_path=self.counter_incomming.getRelativeUrl(), quantity=0.0)
192
    # Nothing in HQ counter's incomming
193 194 195
    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)
196 197 198 199 200

  def stepCreateMutilatedBanknote(self, sequence=None, sequence_list=None, **kwd):
    """
    Create a mutilated banknote document and check it
    """
201 202 203 204 205 206
    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',
207
                                    deponent="user",
208 209
                                    destination_value=self.mutilated_banknote_vault,
                                    site_value=self.paris)
210
    self.stepTic()
211
    self.assertTrue(len(self.mutilated_banknote_module.objectValues()) != 0)
212
    self.assertEqual(self.mutilated_banknote.getPortalType(), 'Mutilated Banknote')
213
    self.assertEqual(self.mutilated_banknote.getSource(), 'site/testsite/paris/surface/banque_interne/guichet_1')
214
    self.assertEqual(self.mutilated_banknote.getSourceTrade(), 'site/testsite/paris')
Aurel's avatar
Aurel committed
215
    self.assertEqual(self.mutilated_banknote.getDestination(), self.mutilated_banknote_vault.getRelativeUrl())
216 217 218 219 220
    # set source reference
    self.setDocumentSourceReference(self.mutilated_banknote)
    # check source reference
    self.assertNotEqual(self.mutilated_banknote.getSourceReference(), '')
    self.assertNotEqual(self.mutilated_banknote.getSourceReference(), None)
221 222 223
    # headquarter is used in order to know if the document will go to the
    # headquarter or not.
    sequence.edit(headquarter=0)
224

225

226
  def stepTryDraftWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
227
    """
228
    Try to stop with no amount defined on the document
229
    """
230
    self.assertEqual(len(self.mutilated_banknote.objectValues()), 0)
231
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow')
232

233
  def stepTryHQDraftWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
234 235 236 237
    """
    Try to stop with no amount defined on the document
    """
    self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 0)
238
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow')
239
    
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
  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)
258
    mutilated_banknote_destination = self.mutilated_banknote.getDestination()
259 260 261 262 263
    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)
264
      self.assertEqual(cell.getBaobabDestination(), None)
265 266 267 268 269 270 271
      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())

272
  def stepTryDraftWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw):
273
    """
274
    Try to stop with no amount defined on the document
275 276
    """
    self.assertEqual(self.mutilated_banknote.getSourceTotalAssetPrice(), 0.0)
277
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow')
278

279
  def stepTryHQDraftWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw):
280 281 282 283
    """
    Try to stop with no amount defined on the document
    """
    self.assertEqual(self.hq_mutilated_banknote.getSourceTotalAssetPrice(), 0.0)
284 285 286
    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):
287 288 289 290 291 292
    """
    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)
293 294 295 296 297
    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):
298 299 300 301 302 303
    """
    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)
304 305 306
    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")
307

308
  def stepStopDocument(self, sequence=None, sequence_list=None, **kw):
309
    """
310
    Stop mutilated banknote operation
311
    """
312
    self.workflow_tool.doActionFor(self.mutilated_banknote, 'stop_action', wf_id='mutilated_banknote_workflow')
313
    self.stepTic()
314
    self.assertEqual(self.mutilated_banknote.getSimulationState(), "stopped")
315

316
  def stepCreateExchangedLine(self, sequence=None, sequence_list=None, **kw):
317 318 319 320
    """
    """
    # create an exchanged
    self.addCashLineToDelivery(self.mutilated_banknote, 'exchanged_line', 'Exchanged Mutilated Banknote Line', self.billet_10000,
321
                               ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/cancelled') + self.variation_list,
322 323 324 325 326 327 328 329 330 331 332 333
                               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:
334
      cell = self.exchanged_line.getCell('emission_letter/not_defined', variation, 'cash_status/cancelled')
335 336 337
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      self.assertEqual(cell.getResourceValue(), self.billet_10000)
      self.assertEqual(cell.getBaobabSourceValue(), None)
338
      self.assertEqual(cell.getBaobabDestinationValue(), None)
339 340 341 342 343 344 345
      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())

346
  def stepTryPlanWithExchangedLine(self, sequence=None, sequence_list=None, **kw):
347
    """
348
    Try to plan with exchanged line defined
349 350
    """
    self.assertEqual(len(self.mutilated_banknote.objectValues(portal_type='Exchanged Mutilated Banknote Line')), 1.0)
351
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow')
352

353
  def stepPlanDocument(self, sequence=None, sequence_list=None, **kw):
354
    """
355
    Plan mutilated banknote operation
356
    """
357
    self.workflow_tool.doActionFor(self.mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow')
358
    self.stepTic()
359
    self.assertEqual(self.mutilated_banknote.getSimulationState(), "planned")
360

361 362 363 364 365 366 367 368
  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):
    """
369 370
    Deliver mutilated banknote operation.
    Also sets the exchanged amount on the document.
371 372 373 374 375 376 377
    """
    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")

378 379 380 381 382 383 384 385 386 387 388
  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")

389 390
  def stepCheckFinalInventoryWithNoPayBack(self, sequence=None, sequence_list=None, **kwd):
    """
391
    Check the final inventory when document got rejected without HQ request
392
    """
393 394 395
    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)
396
    self.checkFinalInventory()
397

398
  stepCheckFinalInventoryWithNoPayBackAfterHQRequest = stepCheckFinalInventoryWithNoPayBack
399

400 401 402 403
  def stepClearMutilatedBanknoteModule(self, sequence=None, sequence_list=None, **kw):
    """
    Remove all operations in module
    """
404
    delattr(self, 'mutilated_banknote')
405 406
    self.mutilated_banknote_module.deleteContent('mutilated_banknote')    

407
  def stepTryFinishWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
408
    """
409
    Try to confirm with no line defined on the document
410 411
    """
    self.assertEqual(len(self.mutilated_banknote.objectValues(portal_type="Exchanged Mutilated Banknote Line")), 0.0)
412
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow')
413

414 415 416 417 418 419 420
  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')

421
  def stepTryDepositHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
422
    """
423
    Try to deposit with no line defined on the document
424 425
    """
    self.assertEqual(len(self.hq_mutilated_banknote.objectValues(portal_type="Exchanged Mutilated Banknote Line")), 0.0)
426
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow')
427

428
  def stepTryFinishWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw):
429 430 431 432
    """
    Try to confirm with no amount defined on the document
    """
    self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 0.0)
433 434 435 436 437 438 439 440
    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')
441

442
  def stepTryDepositHQWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw):
443
    """
444
    Try to deposit with no amount defined on the document
445 446
    """
    self.assertEqual(self.hq_mutilated_banknote.getDestinationTotalAssetPrice(), 0.0)
447
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'deposit_action', wf_id='mutilated_banknote_workflow')
448

449
  def stepFinishDocument(self, sequence=None, sequence_list=None, **kw):
450
    """
451
    Finish mutilated banknote operation (send to counter)
452 453 454
    """
    self.mutilated_banknote.setDestinationTotalAssetPrice(50000.0)
    self.assertEqual(self.mutilated_banknote.getDestinationTotalAssetPrice(), 50000.0)
455
    self.workflow_tool.doActionFor(self.mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow')
456
    self.stepTic()
457
    self.assertEqual(self.mutilated_banknote.getSimulationState(), "finished")
458 459 460

  def stepTryDeliverWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
    """
461
    Try to deliver with no outgoing line defined on the document
462 463 464 465
    """
    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')

466 467 468 469 470 471 472 473
  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')

474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
  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):
490 491 492
    """
    """
    # create an exchanged
493
    self.addCashLineToDelivery(mutilated_banknote, 'outgoing_line', 'Outgoing Mutilated Banknote Line', self.billet_10000,
494
                               ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/valid') + self.variation_list,
495 496 497
                               self.quantity_10000)
    self.stepTic()
    # get the line
498
    self.outgoing_line = getattr(mutilated_banknote, 'outgoing_line')
499 500 501 502 503 504 505
    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:
506
      cell = self.outgoing_line.getCell('emission_letter/not_defined', variation, 'cash_status/valid')
507 508
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      self.assertEqual(cell.getResourceValue(), self.billet_10000)
509
      self.assertEqual(cell.getBaobabSource(), None)
510 511 512 513 514 515 516 517
      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())

518 519 520 521 522 523 524 525 526 527
  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)

528
  def stepCheckFinalInventoryWithPayBack(self, sequence=None, sequence_list=None, **kwd):
529 530 531
    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)
532
    self.checkFinalInventory()
533

534
  def checkFinalInventory(self):
535
    self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0)
536 537 538 539
    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)
540 541
    self.checkBanknoteInventory(node_path=self.usual_vault.getRelativeUrl(), quantity=0.0)
    self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0)
542

543
  def stepCheckFinalInventoryWithPayBackAfterHQRequest(self, sequence=None, sequence_list=None, **kw):
544 545 546 547
    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})
548
    for offset in (-1, 1):
549 550 551 552
      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})
553 554 555 556
      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})
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579

  #
  # 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
580
    self.checkBanknoteInventory(node_path=self.hq_counter.getRelativeUrl(), quantity=5.0)
581 582 583 584
    # 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)
585 586
    # nothing in usual vault
    self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0)
587

588
  def stepCreateHQMutilatedBanknote(self, sequence=None, sequence_list=None,
589
      owner_assigned_counter='site/siege/surface/banque_interne/guichet_1', **kwd):
590 591 592 593
    """
    Create a mutilated banknote document and check it
    """
    self.hq_mutilated_banknote = self.mutilated_banknote_module.newContent(id='hq_mutilated_banknote',
594 595 596
                                                                           portal_type='Mutilated Banknote',
                                                                           source_total_asset_price=0.0,
                                                                           destination_total_asset_price=0.0,
597
                                                                           destination_value=self.hq_mutilated_banknote_vault,
598
                                                                           deponent="hq user",
599 600
                                                                           causality_value=getattr(self, 'mutilated_banknote', None),
                                                                           site_value=self.siege)
601
    self.hq_mutilated_banknote.edit(source_trade='site/testsite/paris')
602
    self.stepTic()
603
    self.assertTrue(len(self.mutilated_banknote_module.objectValues()) != 0)
604
    self.assertEqual(self.hq_mutilated_banknote.getPortalType(), 'Mutilated Banknote')
605
    self.assertEqual(self.hq_mutilated_banknote.getSource(), owner_assigned_counter)
606
    self.assertEqual(self.hq_mutilated_banknote.getSourceTrade(), 'site/testsite/paris')
Aurel's avatar
Aurel committed
607
    self.assertEqual(self.hq_mutilated_banknote.getDestination(), self.hq_mutilated_banknote_vault.getRelativeUrl())
608 609 610 611 612 613
    # 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)

614

615
  def stepTryDraftHQWithNoLineDefined(self, sequence=None, sequence_list=None, **kw):
616 617 618 619
    """
    Try to plan with no amount defined on the document
    """
    self.assertEqual(len(self.hq_mutilated_banknote.objectValues()), 0.0)
620
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow')
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639

  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)
640
    hq_mutilated_banknote_destination = self.hq_mutilated_banknote.getDestination()
641 642 643 644 645
    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)
646
      self.assertEqual(cell.getBaobabDestination(), None)
647 648 649 650 651 652 653
      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())

654
  def stepTryDraftHQWithNoAmountDefined(self, sequence=None, sequence_list=None, **kw):
655 656 657 658
    """
    Try to plan with no amount defined on the document
    """
    self.assertEqual(self.hq_mutilated_banknote.getSourceTotalAssetPrice(), 0.0)
659
    self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'draft_action', wf_id='mutilated_banknote_workflow')
660

661
  def stepStopHQDocument(self, sequence=None, sequence_list=None, **kw):
662 663 664
    """
    Plan mutilated banknote operation
    """
665
    self.workflow_tool.doActionFor(self.hq_mutilated_banknote, 'stop_action', wf_id='mutilated_banknote_workflow')
666
    self.stepTic()
667
    self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "stopped")
668

669
  def stepTryPlanHQDocument(self, sequence=None, sequence_list=None, **kw):
670
    """
671
      It must not be possible (ie, action not present) to plan when the document is initiated in HQ.
672
    """
673 674
    self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'plan_action', wf_id='mutilated_banknote_workflow')

675
  def stepTryFinishHQDocument(self, sequence=None, sequence_list=None, **kw):
676
    """
677
      It must not be possible (ie, action not present) to finish when the document is sent to HQ.
678
    """
679
    self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.hq_mutilated_banknote, 'finish_action', wf_id='mutilated_banknote_workflow')
680 681 682 683 684 685 686 687 688

  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')
689
    self.stepTic()
690
    self.assertEqual(self.hq_mutilated_banknote.getSimulationState(), "finished")
691
    sequence.edit(headquarter=1)
692

693
  def checkBanknoteInventory(self, node_path, quantity, get_inventory_kw=None):
694 695 696
    """
      Check that node contains expected quantity of banknotes.
    """
697 698
    if get_inventory_kw is None:
      get_inventory_kw = {}
699
    resource_path = self.billet_10000.getRelativeUrl()
700 701
    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)
702 703 704 705 706 707 708

  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)

709
  def stepCheckHQFinalInventoryWithNoPayBack(self, sequence=None, sequence_list=None, **kwd):
710 711 712
    """
    Check the initial inventory before any operations
    """
713
    self.checkBanknoteInventory(node_path=self.counter.getRelativeUrl(), quantity=5.0)
714
    self.checkBanknoteInventory(node_path=self.hq_mutilated_banknote_vault.getRelativeUrl(), quantity=0.0)
715
    self.checkBanknoteInventory(node_path=self.hq_counter_incomming.getRelativeUrl(), quantity=0.0)
716
    self.checkFinalInventory()
717 718 719 720 721

  def stepClearHQMutilatedBanknoteModule(self, sequence=None, sequence_list=None, **kw):
    """
    Remove all operations in module
    """
722
    delattr(self, 'hq_mutilated_banknote')
723
    self.mutilated_banknote_module.deleteContent('hq_mutilated_banknote')    
724

725
  def stepCreateHQExchangedLine(self, sequence=None, sequence_list=None, **kw):
726 727 728 729
    """
    """
    # create an exchanged
    self.addCashLineToDelivery(self.hq_mutilated_banknote, 'hq_exchanged_line', 'Exchanged Mutilated Banknote Line', self.billet_10000,
730
                               ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/cancelled') + self.variation_list,
731 732 733 734 735 736 737 738 739 740 741 742
                               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:
743
      cell = self.hq_exchanged_line.getCell('emission_letter/not_defined', variation, 'cash_status/cancelled')
744 745 746
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      self.assertEqual(cell.getResourceValue(), self.billet_10000)
      self.assertEqual(cell.getBaobabSourceValue(), None)
747
      self.assertEqual(cell.getBaobabDestination(), None)
748 749 750 751 752 753
      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())
754

755 756
  def stepCheckHQFinalInventoryWithPayBack(self, sequence=None, sequence_list=None, **kwd):
    """
757
    Check the final inventory when the mutilated payment was approved by headquaters.
758
    """
759 760
    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})
761
    for offset in (-1, 1):
762 763 764 765
      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})
766 767 768 769
      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})
770

771 772
  def stepCheckHQFinalInventoryWithHQPayBack(self, sequence=None, sequence_list=None, **kwd):
    self.checkBanknoteInventory(node_path=self.hq_usual_vault.getRelativeUrl(), quantity=0.0)
773 774 775 776
    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)
777 778 779 780 781
    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)

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
  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)

808 809 810 811 812 813 814 815 816 817 818
  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)
819

820 821
  def moveToFuture(self, document):
    """
822
      Set document's stop date to self.future_date.
823 824 825 826 827 828 829 830 831
    """
    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)

832 833 834 835 836 837 838 839 840 841
  ##################################
  ##  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
842
    # sequence 1 : no payback, mutilated banknotes
843
    sequence_string_1 = 'Tic CheckObjects Tic CheckInitialInventory ' \
844 845 846
                        + 'CreateMutilatedBanknote Tic TryDraftWithNoLineDefined ' \
                        + 'CreateIncomingLine Tic TryDraftWithNoAmountDefined ' \
                        + 'DraftDocument Tic StopDocument Tic ' \
847
                        + 'CheckInventoryWithIncommingMutilatedBanknotes ' \
848
                        + 'CancelDocument Tic ' \
849
                        + 'CheckFinalInventoryWithNoPayBack ClearMutilatedBanknoteModule'
850
    
851
    # sequence 2 : pay back, maculated banknotes
852
    sequence_string_2 = 'Tic CheckObjects Tic CheckInitialInventory ' \
853
                        + 'CreateMutilatedBanknote SetMaculatedState Tic ' \
854
                        + 'CreateIncomingLine Tic ' \
855
                        + 'DraftDocument Tic StopDocument Tic ' \
856
                        + 'CheckInventoryWithIncommingMaculatedBanknotes ' \
857 858 859
                        + 'TryFinishWithNoLineDefined CreateExchangedLine Tic TryFinishWithNoAmountDefined FinishDocument Tic ' \
                        + 'TryDeliverWithNoLineDefined CreateOutgoingLine Tic TryDeliverWithWrongAmountDefined DeliverDocument Tic ' \
                        + 'CheckFinalInventoryWithPayBack ClearMutilatedBanknoteModule'
860

861
    # sequence 3 : ask headquarters then no payback, mutilated banknotes
862
    sequence_string_3 = 'Tic CheckObjects Tic CheckInitialInventory ' \
863 864
                        + 'CreateMutilatedBanknote Tic ' \
                        + 'CreateIncomingLine Tic ' \
865
                        + 'DraftDocument Tic StopDocument Tic ' \
866
                        + 'CheckInventoryWithIncommingMutilatedBanknotes ' \
867 868 869 870
                        + 'CreateExchangedLine Tic TryPlanWithExchangedLine DelExchangedLine Tic PlanDocument Tic ' \
                        + 'HQLogin ' \
                        + 'CheckHQInitialInventory ' \
                        + 'CreateHQMutilatedBanknote Tic '\
871
                        + 'TryDraftHQWithNoLineDefined Tic CreateHQIncomingLine Tic TryDraftHQWithNoAmountDefined DraftHQDocument Tic StopHQDocument Tic ' \
872
                        + 'CheckHQInventoryWithIncommingMutilatedBanknotes ' \
873
                        + 'TryPlanHQDocument ' \
874
                        + 'CancelHQDocument Tic ' \
875
                        + 'HQLogout ' \
876
                        + 'CheckHQFinalInventoryWithNoPayBack ' \
877
                        + 'ArchiveDocument Tic ' \
878
                        + 'CheckFinalInventoryWithNoPayBackAfterHQRequest ClearMutilatedBanknoteModule ClearHQMutilatedBanknoteModule'
879
    
880
    # sequence 4 : ask headquarters then payback, maculated banknotes
881
    sequence_string_4 = 'Tic CheckObjects Tic CheckInitialInventory ' \
882
                        + 'CreateMutilatedBanknote SetMaculatedState Tic ' \
883
                        + 'CreateIncomingLine Tic ' \
884
                        + 'DraftDocument Tic StopDocument Tic ' \
885 886 887
                        + 'PlanDocument Tic ' \
                        + 'HQLogin ' \
                        + 'CheckHQInitialInventory ' \
888
                        + 'CreateHQMutilatedBanknote SetHQMaculatedState Tic ' \
889
                        + 'CreateHQIncomingLine Tic DraftHQDocument Tic StopHQDocument Tic ' \
890
                        + 'MoveHQToFuture Tic ' \
891
                        + 'CheckHQInventoryWithIncommingMaculatedBanknotes ' \
892
                        + 'CheckHQMaculatedBanknoteInventory ' \
893
                        + 'TryDepositHQWithNoLineDefined CreateHQExchangedLine Tic TryDepositHQWithNoAmountDefined DepositHQDocument Tic ' \
894
                        + 'HQLogout ' \
895
                        + 'CheckHQFinalInventoryWithPayBack '\
896
                        + 'MoveToFuture Tic ' \
897 898
                        + 'CreateExchangedLine Tic FinishDocument Tic ' \
                        + 'CreateOutgoingLine Tic DeliverDocument Tic ' \
899
                        + 'CheckFinalInventoryWithPayBackAfterHQRequest ClearMutilatedBanknoteModule ClearHQMutilatedBanknoteModule'
900

901 902 903
    # sequence 5 : HQ, no payback, mutilated banknotes
    sequence_string_5 = 'Tic CheckObjects Tic CheckHQInitialInventory ' \
                        'HQLogin ' \
904 905 906
                        'CreateHQMutilatedBanknote Tic TryHQDraftWithNoLineDefined ' \
                        'CreateHQIncomingLine Tic TryHQDraftWithNoAmountDefined ' \
                        'DraftHQDocument Tic StopHQDocument Tic ' \
907 908 909 910 911 912 913 914 915
                        '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 ' \
916
                        'DraftHQDocument Tic StopHQDocument Tic ' \
917 918 919 920 921
                        'CheckHQInventoryWithIncommingMaculatedBanknotes ' \
                        'TryFinishHQWithNoLineDefined CreateHQExchangedLine Tic TryFinishHQWithNoAmountDefined FinishHQDocument Tic ' \
                        'TryDeliverHQWithNoLineDefined CreateHQOutgoingLine Tic TryDeliverHQWithWrongAmountDefined DeliverHQDocument Tic ' \
                        'CheckHQFinalInventoryWithHQPayBack ClearHQMutilatedBanknoteModule'

922 923 924
    #sequence_list.addSequenceString(sequence_string_1)
    #sequence_list.addSequenceString(sequence_string_2)
    #sequence_list.addSequenceString(sequence_string_3)
925
    sequence_list.addSequenceString(sequence_string_4)
926 927
    sequence_list.addSequenceString(sequence_string_5)
    sequence_list.addSequenceString(sequence_string_6)
928 929 930 931 932 933 934 935 936 937 938 939
    # 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(TestERP5BankingMutilatedBanknote))
    return suite