testERP5BankingCashClassification.py 43.2 KB
Newer Older
Yoshinori Okuji's avatar
Yoshinori Okuji committed
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
##############################################################################
#
# Copyright (c) 2005-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
34
from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin
Yoshinori Okuji's avatar
Yoshinori Okuji committed
35 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 TestERP5BankingCashClassification(TestERP5BankingMixin):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
48 49 50 51 52 53 54 55 56 57 58 59 60


  # 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 "ERP5BankingCashClassification"

61
  def getCashSortingModule(self):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
62
    """
63
    Return the Cash Sorting Module
Yoshinori Okuji's avatar
Yoshinori Okuji committed
64
    """
65
    return getattr(self.getPortal(), 'cash_sorting_module', None)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
66 67 68 69 70 71


  def afterSetUp(self):
    """
      Method called before the launch of the test to initialize some data
    """
72
    self.initDefaultVariable()
73 74
    # Set some variables :
    self.cash_sorting_module = self.getCashSortingModule()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
75 76 77 78

    # Create a user and login as manager to populate the erp5 portal with objects for tests.
    self.createManagerAndLogin()

79
    self.createFunctionGroupSiteCategory(site_list=('paris',))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
80 81


82 83 84
    inventory_dict_line_1 = {'id' : 'inventory_line_1',
                             'resource': self.billet_10000,
                             'variation_id': ('emission_letter', 'cash_status', 'variation'),
85
                             'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
86
                             'quantity': self.quantity_10000}
87

88 89 90
    inventory_dict_line_2 = {'id' : 'inventory_line_2',
                             'resource': self.billet_200,
                             'variation_id': ('emission_letter', 'cash_status', 'variation'),
91
                             'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
92
                             'quantity': self.quantity_200}
93 94 95 96 97 98 99

    inventory_dict_line_3 = {'id' : 'inventory_line_3',
                             'resource': self.billet_5000,
                             'variation_id': ('emission_letter', 'cash_status', 'variation'),
                             'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
                             'quantity': self.quantity_5000}

100 101 102 103 104 105
    inventory_dict_line_4 = {'id' : 'inventory_line_4',
                             'resource': self.billet_100,
                             'variation_id': ('emission_letter', 'cash_status', 'variation'),
                             'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
                             'quantity': self.quantity_100}

106

107 108 109

    line_list = [inventory_dict_line_1, inventory_dict_line_2, inventory_dict_line_3,
                 inventory_dict_line_4]
110
    self.encaisse_tri = self.paris.surface.salle_tri.encaisse_des_billets_recus_pour_ventilation.madrid
111
    self.encaisse_reserve = self.paris.caveau.reserve.encaisse_des_billets_et_monnaies
112 113 114 115
    self.encaisse_aux_externe = self.paris.caveau.auxiliaire.encaisse_des_externes
    #self.encaisse_aux_bm = self.paris.caveau.auxiliaire.encaisse_des_billets_recus_pour_ventilation.madrid
    self.encaisse_aux_bm = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies
    self.encaisse_aux_ventil_madrid = self.paris.caveau.auxiliaire.encaisse_des_billets_recus_pour_ventilation.madrid
116 117

    self.createCashInventory(source=None, destination=self.encaisse_tri, currency=self.currency_1,
118
                             line_list=line_list)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
119

120 121 122 123 124 125 126 127 128 129 130 131 132 133
    # now we need to create a user as Manager to do the test
    # in order to have an assigment defined which is used to do transition
    # Create an Organisation that will be used for users assignment
    self.checkUserFolderType()
    self.organisation = self.organisation_module.newContent(id='paris', portal_type='Organisation',
                          function='banking', group='baobab',  site='testsite/paris')
    # define the user
    user_dict = {
        'super_user' : [['Manager'], self.organisation, 'banking/comptable', 'baobab', 'testsite/paris']
      }
    # call method to create this user
    self.createERP5Users(user_dict)
    self.logout()
    self.login('super_user')
134 135
    # open counter date and counter
    self.openCounterDate(site=self.paris)
136 137


Yoshinori Okuji's avatar
Yoshinori Okuji committed
138 139 140 141 142 143 144

  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.
    """
145
    self.checkResourceCreated()
146 147 148 149
    # check that CashSorting Module was created
    self.assertEqual(self.cash_sorting_module.getPortalType(), 'Cash Sorting Module')
    # check cash sorting module is empty
    self.assertEqual(len(self.cash_sorting_module.objectValues()), 0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
150 151 152 153 154 155 156


  def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd):
    """
    Check the initial inventory before any operations
    """
    self.simulation_tool = self.getSimulationTool()
157 158 159
    # check we have 5 banknotes of 10000 in encaisse_paris
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
160 161 162
    # check we have 10 banknotes of 100 in encaisse_paris
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 10.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 10.0)
163 164 165 166 167
    # check we have 12 coin of 200 in encaisse_paris
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
168 169 170 171


  def stepCheckSource(self, sequence=None, sequence_list=None, **kwd):
    """
172
    Check inventory in source vault (encaisse_paris) before a confirm
Yoshinori Okuji's avatar
Yoshinori Okuji committed
173 174
    """
    # check we have 5 banknotes of 10000
175 176
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
177
    # check we have 12 coin of 200
178 179 180 181
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
182 183 184 185 186 187 188


  def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd):
    """
    Check inventory in destination vault (caisse_2) before confirm
    """
    # check we don't have banknotes of 10000
189 190
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
191 192 193 194
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
195

Yoshinori Okuji's avatar
Yoshinori Okuji committed
196
    # check we don't have coins of 200
197 198
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
199 200 201 202
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
203

204 205 206 207 208 209 210 211
    # check we don't have coins of 100
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)

212 213 214
    # check for banknote of 5000
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
215 216 217 218
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
219 220


221
  def stepCreateCashSorting(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
222
    """
223
    Create a cash sorting document and check it
Yoshinori Okuji's avatar
Yoshinori Okuji committed
224
    """
225
    # Cash sorting has encaisse_paris for source, encaisse_aux_externe for destination, and a price cooreponding to the sum of banknote of 10000 and banknotes of 200 ( (2+3) * 1000 + (5+7) * 200 )
226 227 228 229 230 231 232
    self.cash_sorting = self.cash_sorting_module.newContent(
                               id='cash_sorting_1', 
                               portal_type='Cash Sorting', 
                               source_value=self.encaisse_tri, 
                               description='test',
                               destination_value=None, 
                               source_total_asset_price=52400.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
233 234
    # execute tic
    self.stepTic()
235 236 237 238 239
    # set source reference
    self.setDocumentSourceReference(self.cash_sorting)
    # check source reference
    self.assertNotEqual(self.cash_sorting.getSourceReference(), '')
    self.assertNotEqual(self.cash_sorting.getSourceReference(), None)
240 241 242 243
    # check we have only one cash sorting
    self.assertEqual(len(self.cash_sorting_module.objectValues()), 1)
    # get the cash sorting document
    self.cash_sorting = getattr(self.cash_sorting_module, 'cash_sorting_1')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
244
    # check its portal type
245 246
    self.assertEqual(self.cash_sorting.getPortalType(), 'Cash Sorting')
    # check that its source is encaisse_paris
247
    self.assertEqual(self.cash_sorting.getSource(), 'site/testsite/paris/surface/salle_tri/encaisse_des_billets_recus_pour_ventilation/madrid')
248
    # check that its destination is encaisse_aux_externe
249
    self.assertEqual(self.cash_sorting.getDestination(), None)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
250 251


252
  def stepCreateFourValidIncomingLine(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
253
    """
254
    Create the cash sorting incoming line  with banknotes of 10000 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
255
    """
256 257 258
    # create the cash sorting line
    self.addCashLineToDelivery(self.cash_sorting, 'valid_incoming_line_1', 'Incoming Cash Sorting Line', self.billet_10000,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
Yoshinori Okuji's avatar
Yoshinori Okuji committed
259 260 261 262
            self.quantity_10000)
    # execute tic
    self.stepTic()
    # check there is only one line created
263 264 265
    self.assertEqual(len(self.cash_sorting.objectValues()), 1)
    # get the cash sorting line
    self.valid_incoming_line = getattr(self.cash_sorting, 'valid_incoming_line_1')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
266
    # check its portal type
267
    self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
268 269 270 271 272
    # check the resource is banknotes of 10000
    self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_10000)
    # chek the value of the banknote
    self.assertEqual(self.valid_incoming_line.getPrice(), 10000.0)
    # check the unit of banknote
273
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
274 275 276 277 278
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_incoming_line.objectValues()), 2)
    # now check for each variation (years 1992 and 2003)
    for variation in self.variation_list:
      # get the delivery cell
279
      cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
280 281 282 283
      # chek portal types
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      # check the banknote of the cell is banknote of 10000
      self.assertEqual(cell.getResourceValue(), self.billet_10000)
284 285
      # check the source vault is encaisse_paris
      self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
286
      # check the destination vault is encaisse_aux_externe
Yoshinori Okuji's avatar
Yoshinori Okuji committed
287 288 289 290 291 292 293 294 295 296
      self.assertEqual(cell.getDestinationValue(), None)
      if cell.getId() == 'movement_0_0_0':
        # check the quantity of banknote for year 1992 is 2
        self.assertEqual(cell.getQuantity(), 2.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity of banknote for year 2003 is 3
        self.assertEqual(cell.getQuantity(), 3.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
    self.addCashLineToDelivery(self.cash_sorting, 'valid_incoming_line_2', 'Incoming Cash Sorting Line', self.billet_200,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
            self.quantity_200)
    # execute tic
    self.stepTic()
    # check there is only one line created
    self.assertEqual(len(self.cash_sorting.objectValues()), 2)
    # get the cash sorting line
    self.valid_incoming_line = getattr(self.cash_sorting, 'valid_incoming_line_2')
    # check its portal type
    self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
    # check the resource is banknotes of 10000
    self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_200)
    # chek the value of the banknote
    self.assertEqual(self.valid_incoming_line.getPrice(), 200.0)
    # check the unit of banknote
313
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
314 315 316 317 318 319 320 321 322 323 324 325
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_incoming_line.objectValues()), 2)
    # now check for each variation (years 1992 and 2003)
    for variation in self.variation_list:
      # get the delivery cell
      cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
      # chek portal types
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      # check the banknote of the cell is banknote of 10000
      self.assertEqual(cell.getResourceValue(), self.billet_200)
      # check the source vault is encaisse_paris
      self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
326
      # check the destination vault is encaisse_aux_externe
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
      self.assertEqual(cell.getDestinationValue(), None)
      if cell.getId() == 'movement_0_0_0':
        # check the quantity of banknote for year 1992 is 2
        self.assertEqual(cell.getQuantity(), 5.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity of banknote for year 2003 is 3
        self.assertEqual(cell.getQuantity(), 7.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())

    self.addCashLineToDelivery(self.cash_sorting, 'valid_incoming_line_3', 'Incoming Cash Sorting Line', self.billet_5000,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
            self.quantity_5000)
    # execute tic
    self.stepTic()
    # check there is only one line created
    self.assertEqual(len(self.cash_sorting.objectValues()), 3)
    # get the cash sorting line
    self.valid_incoming_line = getattr(self.cash_sorting, 'valid_incoming_line_3')
    # check its portal type
    self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
    # check the resource is banknotes of 10000
    self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_5000)
    # chek the value of the banknote
    self.assertEqual(self.valid_incoming_line.getPrice(), 5000.0)
    # check the unit of banknote
353
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
354 355 356 357 358 359 360 361 362 363 364 365
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_incoming_line.objectValues()), 2)
    # now check for each variation (years 1992 and 2003)
    for variation in self.variation_list:
      # get the delivery cell
      cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
      # chek portal types
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      # check the banknote of the cell is banknote of 10000
      self.assertEqual(cell.getResourceValue(), self.billet_5000)
      # check the source vault is encaisse_paris
      self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
366
      # check the destination vault is encaisse_aux_externe
367 368 369 370 371 372 373 374 375 376
      self.assertEqual(cell.getDestinationValue(), None)
      if cell.getId() == 'movement_0_0_0':
        # check the quantity of banknote for year 1992 is 2
        self.assertEqual(cell.getQuantity(), 11.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity of banknote for year 2003 is 3
        self.assertEqual(cell.getQuantity(), 13.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
    self.addCashLineToDelivery(self.cash_sorting, 'valid_incoming_line_4', 'Incoming Cash Sorting Line', self.billet_100,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
            self.quantity_100)
    # execute tic
    self.stepTic()
    # check there is only one line created
    self.assertEqual(len(self.cash_sorting.objectValues()), 4)
    # get the cash sorting line
    self.valid_incoming_line = getattr(self.cash_sorting, 'valid_incoming_line_4')
    # check its portal type
    self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
    # check the resource is banknotes of 10000
    self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_100)
    # chek the value of the banknote
    self.assertEqual(self.valid_incoming_line.getPrice(), 100.0)
    # check the unit of banknote
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_incoming_line.objectValues()), 2)
    # now check for each variation (years 1992 and 2003)
    for variation in self.variation_list:
      # get the delivery cell
      cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
      # chek portal types
      self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
      # check the banknote of the cell is banknote of 10000
      self.assertEqual(cell.getResourceValue(), self.billet_100)
      # check the source vault is encaisse_paris
      self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
      # check the destination vault is encaisse_aux_externe
      self.assertEqual(cell.getDestinationValue(), None)
      if cell.getId() == 'movement_0_0_0':
        # check the quantity of banknote for year 1992 is 2
        self.assertEqual(cell.getQuantity(), 4.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity of banknote for year 2003 is 3
        self.assertEqual(cell.getQuantity(), 6.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())
Yoshinori Okuji's avatar
Yoshinori Okuji committed
416 417 418

  def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd):
    """
419
    Check the amount after the creation of cash sorting line 1
Yoshinori Okuji's avatar
Yoshinori Okuji committed
420 421
    """
    # Check number of lines
422
    self.assertEqual(len(self.cash_sorting.objectValues()), 4)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
423
    # Check quantity of banknotes (2 for 1992 and 3 for 2003)
424
    self.assertEqual(self.cash_sorting.getTotalQuantity(fast=0, portal_type="Incoming Cash Sorting Line"), 51.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
425
    # Check the total price
426
    self.assertEqual(self.cash_sorting.getTotalPrice(fast=0, portal_type="Incoming Cash Sorting Line"), 10000 * 5.0 + 100 * 10.0 + 200 * 12.0 + 5000 * 24.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
427 428


429
  def stepCreateValidOutgoingLineForInternalBanknote(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
430
    """
431
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
432 433
    """
    # create the line
434
    self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_1', 'Outgoing Cash Sorting Line', self.billet_10000,
Aurel's avatar
Aurel committed
435
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
436
            self.quantity_10000)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
437 438 439
    # execute tic
    self.stepTic()
    # check the number of lines (line1 + line2)
440
    self.assertEqual(len(self.cash_sorting.objectValues()), 5)
441 442
    # get the second cash sorting line
    self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_1')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
443
    # check portal types
444
    self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
445
    # check the resource is coin of 200
446
    self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_10000)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
447
    # check the value of coin
448
    self.assertEqual(self.valid_outgoing_line.getPrice(), 10000.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
449
    # check the unit of coin
450
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
451 452 453 454
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
    for variation in self.variation_list:
      # get the delivery  cell
Aurel's avatar
Aurel committed
455
      cell = self.valid_outgoing_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
456
      # check the portal type
457
      self.assertEqual(cell.getPortalType(), 'Outgoing Cash Sorting Cell')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
458 459
      if cell.getId() == 'movement_0_0_0':
        # check the quantity for coin for year 1992 is 5
460
        self.assertEqual(cell.getQuantity(), 2.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
461 462
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity for coin for year 2003 is 7
463
        self.assertEqual(cell.getQuantity(), 3.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
464 465 466
      else:
        self.fail('Wrong cell created : %s' % cell.getId())

467 468

  def stepCreateValidOutgoingLineForExternalBanknote(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
469
    """
470
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
471
    """
472 473 474 475
    # create the line
    self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_2', 'Outgoing Cash Sorting Line', self.billet_200,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/s', 'cash_status/valid') + self.variation_list,
            self.quantity_200)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
476 477
    # execute tic
    self.stepTic()
478
    # check the number of lines (line1 + line2)
479
    self.assertEqual(len(self.cash_sorting.objectValues()), 6)
480 481 482 483 484 485 486 487 488
    # get the second cash sorting line
    self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_2')
    # check portal types
    self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
    # check the resource is coin of 200
    self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_200)
    # check the value of coin
    self.assertEqual(self.valid_outgoing_line.getPrice(), 200.0)
    # check the unit of coin
489
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
    for variation in self.variation_list:
      # get the delivery  cell
      cell = self.valid_outgoing_line.getCell('emission_letter/s', variation, 'cash_status/valid')
      # check the portal type
      self.assertEqual(cell.getPortalType(), 'Outgoing Cash Sorting Cell')
      if cell.getId() == 'movement_0_0_0':
        # check the quantity for coin for year 1992 is 5
        self.assertEqual(cell.getQuantity(), 5.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity for coin for year 2003 is 7
        self.assertEqual(cell.getQuantity(), 7.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())
Yoshinori Okuji's avatar
Yoshinori Okuji committed
505

506 507 508 509 510 511
  def stepCreateValidOutgoingLineForMixed(self, sequence=None, sequence_list=None, **kwd):
    """
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
    """
    # create the line
    self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_4', 'Outgoing Cash Sorting Line', self.billet_100,
512
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/mixed', 'cash_status/valid') + self.variation_list,
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
            self.quantity_100)
    # execute tic
    self.stepTic()
    # check the number of lines (line1 + line2)
    self.assertEqual(len(self.cash_sorting.objectValues()), 8)
    # get the second cash sorting line
    self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_4')
    # check portal types
    self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
    # check the resource is coin of 200
    self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_100)
    # check the value of coin
    self.assertEqual(self.valid_outgoing_line.getPrice(), 100.0)
    # check the unit of coin
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
    for variation in self.variation_list:
      # get the delivery  cell
532
      cell = self.valid_outgoing_line.getCell('emission_letter/mixed', variation, 'cash_status/valid')
533 534 535 536 537 538 539 540 541 542
      # check the portal type
      self.assertEqual(cell.getPortalType(), 'Outgoing Cash Sorting Cell')
      if cell.getId() == 'movement_0_0_0':
        # check the quantity for coin for year 1992 is 5
        self.assertEqual(cell.getQuantity(), 4.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity for coin for year 2003 is 7
        self.assertEqual(cell.getQuantity(), 6.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())
Yoshinori Okuji's avatar
Yoshinori Okuji committed
543

544
  def stepCreateValidOutgoingLineForInternalAndCancelledBanknote(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
545
    """
546
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
547
    """
548 549 550 551
    # create the line
    self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_3', 'Outgoing Cash Sorting Line', self.billet_5000,
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list,
            self.quantity_5000)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
552 553
    # execute tic
    self.stepTic()
554
    # check the number of lines (line1 + line2)
555
    self.assertEqual(len(self.cash_sorting.objectValues()), 7)
556 557 558 559 560 561 562 563 564
    # get the second cash sorting line
    self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_3')
    # check portal types
    self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
    # check the resource is coin of 200
    self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_5000)
    # check the value of coin
    self.assertEqual(self.valid_outgoing_line.getPrice(), 5000.0)
    # check the unit of coin
565
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    # check we have two delivery cells: (one for year 1992 and one for 2003)
    self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
    for variation in self.variation_list:
      # get the delivery  cell
      cell = self.valid_outgoing_line.getCell('emission_letter/p', variation, 'cash_status/cancelled')
      # check the portal type
      self.assertEqual(cell.getPortalType(), 'Outgoing Cash Sorting Cell')
      if cell.getId() == 'movement_0_0_0':
        # check the quantity for coin for year 1992 is 5
        self.assertEqual(cell.getQuantity(), 11.0)
      elif cell.getId() == 'movement_0_1_0':
        # check the quantity for coin for year 2003 is 7
        self.assertEqual(cell.getQuantity(), 13.0)
      else:
        self.fail('Wrong cell created : %s' % cell.getId())
Yoshinori Okuji's avatar
Yoshinori Okuji committed
581 582 583 584


  def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd):
    """
585
    Check the total after the creation of the two cash sorting lines
Yoshinori Okuji's avatar
Yoshinori Okuji committed
586 587
    """
    # Check number of lines (line1 + line2)
588
    self.assertEqual(len(self.cash_sorting.objectValues()), 8)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
589
    # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
590
    self.assertEqual(self.cash_sorting.getTotalQuantity(fast=0), (5.0 + 10.0 + 12.0 + 24.0) * 2.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
591
    # check the total price
592
    self.assertEqual(self.cash_sorting.getTotalPrice(fast=0), (10000 * 5.0 + 100 * 10.0 + 200 * 12.0 + 5000 * 24.0) * 2.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
593 594


595 596 597 598
  def stepConfirmCashSorting(self, sequence=None, sequence_list=None, **kwd):
    """
    Confirm the cash sorting and check it
    """
599
    self.cash_sorting.setSourceTotalAssetPrice('173400.0')
600 601 602 603 604 605 606 607
    # do the Workflow action
    self.workflow_tool.doActionFor(self.cash_sorting, 'confirm_action', wf_id='cash_sorting_workflow')
    # execute tic
    self.stepTic()
    # get state
    state = self.cash_sorting.getSimulationState()
    # check state is confirmed
    self.assertEqual(state, 'confirmed')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
608 609 610 611


  def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd):
    """
612
    Check that compution of inventory at vault encaisse_paris is right after confirm and before deliver
Yoshinori Okuji's avatar
Yoshinori Okuji committed
613 614
    """
    # check we have 5 banknotes of 10000 currently
615
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
616
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
617
    # check we have 12 coins of 200 currently
618
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
619
    # check we will have 0 coin of 200 after deliver
620 621 622 623
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    # check that all banknote of 5000 go to the right cash
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
624 625 626 627


  def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd):
    """
628
    Check that compution of inventory at vault encaisse_aux_externe is right after confirm and before deliver
Yoshinori Okuji's avatar
Yoshinori Okuji committed
629
    """
630
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_ventil_madrid.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
631
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_ventil_madrid.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
632
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
Aurel's avatar
Aurel committed
633 634
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
635 636
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
637
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
638
    # check we have 0 coin of 200 currently
639
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
640
    # check we will have 12 coins of 200 after deliver
641
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
642
    # check for banknote of 5000
643
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
644
    # check we will have 12 coins of 200 after deliver
645
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
646 647


648
  def stepDeliverCashSorting(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
649
    """
650
    Deliver the cash sorting with a good user
Yoshinori Okuji's avatar
Yoshinori Okuji committed
651 652 653 654 655
    and check that the deliver of a cash tranfer have achieved
    """
    #     self.security_manager = AccessControl.getSecurityManager()
    #     self.user = self.security_manager.getUser()
    # do the workflow transition "deliver_action"
656
    self.workflow_tool.doActionFor(self.cash_sorting, 'deliver_action', wf_id='cash_sorting_workflow')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
657 658
    # execute tic
    self.stepTic()
659 660
    # get state of cash sorting
    state = self.cash_sorting.getSimulationState()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
661 662
    # check that state is delivered
    self.assertEqual(state, 'delivered')
663

Yoshinori Okuji's avatar
Yoshinori Okuji committed
664 665 666

  def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd):
    """
667
    Check inventory at source (vault encaisse_paris) after deliver of the cash sorting
Yoshinori Okuji's avatar
Yoshinori Okuji committed
668 669
    """
    # check we have 0 banknote of 10000
670 671
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
672
    # check we have 0 coin of 200
673 674 675 676
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
677 678 679
    # check we have 0 coin of 100
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 0.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
680 681 682

  def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd):
    """
683
    Check inventory at destination (vault encaisse_aux_externe) after deliver of the cash sorting
Yoshinori Okuji's avatar
Yoshinori Okuji committed
684
    """
685 686
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_ventil_madrid.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_ventil_madrid.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
Aurel's avatar
Aurel committed
687 688
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
689 690
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
691 692
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)    
Yoshinori Okuji's avatar
Yoshinori Okuji committed
693
    # check we have 12 coins of 200
694 695
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
696
    # check we have 24 banknotes of 5000
697 698
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_bm.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
699 700
    # check we have 10 coins of 100
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 10.0)
Grégory Wisniewski's avatar
Grégory Wisniewski committed
701
    self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_aux_externe.getRelativeUrl(), resource = self.billet_100.getRelativeUrl()), 10.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
702 703 704 705 706 707 708 709 710 711 712 713 714

  ##################################
  ##  Tests
  ##################################

  def test_01_ERP5BankingCashClassification(self, quiet=QUIET, run=RUN_ALL_TEST):
    """
    Define the sequence of step that will be play
    """
    if not run: return
    sequence_list = SequenceList()
    # define the sequence
    sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \
715
                    + 'CreateCashSorting ' \
716
                    + 'CreateFourValidIncomingLine CheckSubTotal ' \
717 718
                    + 'CreateValidOutgoingLineForInternalBanknote ' \
                    + 'CreateValidOutgoingLineForExternalBanknote ' \
719 720 721
                    + 'CreateValidOutgoingLineForInternalAndCancelledBanknote ' \
                    + 'CreateValidOutgoingLineForMixed ' \
                    + 'Tic CheckTotal ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
722
                    + 'CheckSource CheckDestination ' \
723
                    + 'ConfirmCashSorting Tic ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
724
                    + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \
725
                    + 'DeliverCashSorting Tic ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
726 727 728 729 730 731 732 733 734 735 736 737 738 739
                    + 'CheckSourceDebit CheckDestinationCredit '
    sequence_list.addSequenceString(sequence_string)
    # play the sequence
    sequence_list.play(self)

# define how we launch the unit test
if __name__ == '__main__':
  framework()
else:
  import unittest
  def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(TestERP5BankingCashClassification))
    return suite