testERP5BankingMutilatedBanknote.py 52 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
##############################################################################
#
# 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.Sequence import SequenceList
from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed
from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin
35
from DateTime import DateTime
36 37 38 39 40 41 42 43 44 45 46

# 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'))


47
class TestERP5BankingMutilatedBanknote(TestERP5BankingMixin):
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
  """
  """

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

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

  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)

138 139 140 141 142 143 144
  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')

145 146 147 148 149 150 151
  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')

152 153 154 155 156 157 158 159
  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')


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

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

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

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

222

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

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

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

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

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

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

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

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

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

375 376 377 378 379 380 381 382 383 384 385
  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")

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

395
  stepCheckFinalInventoryWithNoPayBackAfterHQRequest = stepCheckFinalInventoryWithNoPayBack
396

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

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

411 412 413 414 415 416 417
  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')

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

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

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

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

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

463 464 465 466 467 468 469 470
  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')

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

515 516 517 518 519 520 521 522 523 524
  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)

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

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

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

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

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

611

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

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

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

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

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

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

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

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

  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)

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

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

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

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

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

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

805 806 807 808 809 810 811 812 813 814 815
  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)
816

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

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

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

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

919 920 921
    #sequence_list.addSequenceString(sequence_string_1)
    #sequence_list.addSequenceString(sequence_string_2)
    #sequence_list.addSequenceString(sequence_string_3)
922
    sequence_list.addSequenceString(sequence_string_4)
923 924
    sequence_list.addSequenceString(sequence_string_5)
    sequence_list.addSequenceString(sequence_string_6)
925 926 927 928 929 930 931 932 933 934 935 936
    # 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