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',))
80
    self.createBanknotesAndCoins()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
81 82


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

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

    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}

101 102 103 104 105 106
    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}

107

108 109 110

    line_list = [inventory_dict_line_1, inventory_dict_line_2, inventory_dict_line_3,
                 inventory_dict_line_4]
111
    self.encaisse_tri = self.paris.surface.salle_tri.encaisse_des_billets_recus_pour_ventilation.madrid
112
    self.encaisse_reserve = self.paris.caveau.reserve.encaisse_des_billets_et_monnaies
113 114 115 116
    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
117 118

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

121 122 123 124 125 126 127 128 129 130 131 132 133 134
    # 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')
135 136
    # open counter date and counter
    self.openCounterDate(site=self.paris)
137 138


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

  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.
    """
146
    self.checkResourceCreated()
147 148 149 150
    # 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
151 152 153 154 155 156 157


  def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd):
    """
    Check the initial inventory before any operations
    """
    self.simulation_tool = self.getSimulationTool()
158 159 160
    # 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)
161 162 163
    # 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)
164 165 166 167 168
    # 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
169 170 171 172


  def stepCheckSource(self, sequence=None, sequence_list=None, **kwd):
    """
173
    Check inventory in source vault (encaisse_paris) before a confirm
Yoshinori Okuji's avatar
Yoshinori Okuji committed
174 175
    """
    # check we have 5 banknotes of 10000
176 177
    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
178
    # check we have 12 coin of 200
179 180 181 182
    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
183 184 185 186 187 188 189


  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
190 191
    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)
192 193 194 195
    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)
196

Yoshinori Okuji's avatar
Yoshinori Okuji committed
197
    # check we don't have coins of 200
198 199
    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)
200 201 202 203
    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)
204

205 206 207 208 209 210 211 212
    # 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)

213 214 215
    # 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)
216 217 218 219
    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
220 221


222
  def stepCreateCashSorting(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
223
    """
224
    Create a cash sorting document and check it
Yoshinori Okuji's avatar
Yoshinori Okuji committed
225
    """
226
    # 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 )
227 228 229 230 231 232 233
    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
234 235
    # execute tic
    self.stepTic()
236 237 238 239 240
    # set source reference
    self.setDocumentSourceReference(self.cash_sorting)
    # check source reference
    self.assertNotEqual(self.cash_sorting.getSourceReference(), '')
    self.assertNotEqual(self.cash_sorting.getSourceReference(), None)
241 242 243 244
    # 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
245
    # check its portal type
246 247
    self.assertEqual(self.cash_sorting.getPortalType(), 'Cash Sorting')
    # check that its source is encaisse_paris
248
    self.assertEqual(self.cash_sorting.getSource(), 'site/testsite/paris/surface/salle_tri/encaisse_des_billets_recus_pour_ventilation/madrid')
249
    # check that its destination is encaisse_aux_externe
250
    self.assertEqual(self.cash_sorting.getDestination(), None)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
251 252


253
  def stepCreateFourValidIncomingLine(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
254
    """
255
    Create the cash sorting incoming line  with banknotes of 10000 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
256
    """
257 258 259
    # 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
260 261 262 263
            self.quantity_10000)
    # execute tic
    self.stepTic()
    # check there is only one line created
264 265 266
    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
267
    # check its portal type
268
    self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
269 270 271 272 273
    # 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
274
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
275 276 277 278 279
    # 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
280
      cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
281 282 283 284
      # 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)
285 286
      # check the source vault is encaisse_paris
      self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
287
      # check the destination vault is encaisse_aux_externe
Yoshinori Okuji's avatar
Yoshinori Okuji committed
288 289 290 291 292 293 294 295 296 297
      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())

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
    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
314
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
315 316 317 318 319 320 321 322 323 324 325 326
    # 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)
327
      # check the destination vault is encaisse_aux_externe
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 353
      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
354
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
355 356 357 358 359 360 361 362 363 364 365 366
    # 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)
367
      # check the destination vault is encaisse_aux_externe
368 369 370 371 372 373 374 375 376 377
      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())

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 416
    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
417 418 419

  def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd):
    """
420
    Check the amount after the creation of cash sorting line 1
Yoshinori Okuji's avatar
Yoshinori Okuji committed
421 422
    """
    # Check number of lines
423
    self.assertEqual(len(self.cash_sorting.objectValues()), 4)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
424
    # Check quantity of banknotes (2 for 1992 and 3 for 2003)
425
    self.assertEqual(self.cash_sorting.getTotalQuantity(fast=0, portal_type="Incoming Cash Sorting Line"), 51.0)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
426
    # Check the total price
427
    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
428 429


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

468 469

  def stepCreateValidOutgoingLineForExternalBanknote(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
470
    """
471
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
472
    """
473 474 475 476
    # 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
477 478
    # execute tic
    self.stepTic()
479
    # check the number of lines (line1 + line2)
480
    self.assertEqual(len(self.cash_sorting.objectValues()), 6)
481 482 483 484 485 486 487 488 489
    # 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
490
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
    # 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
506

507 508 509 510 511 512
  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,
513
            ('emission_letter', 'cash_status', 'variation'), ('emission_letter/mixed', 'cash_status/valid') + self.variation_list,
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
            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
533
      cell = self.valid_outgoing_line.getCell('emission_letter/mixed', variation, 'cash_status/valid')
534 535 536 537 538 539 540 541 542 543
      # 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
544

545
  def stepCreateValidOutgoingLineForInternalAndCancelledBanknote(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
546
    """
547
    Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
Yoshinori Okuji's avatar
Yoshinori Okuji committed
548
    """
549 550 551 552
    # 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
553 554
    # execute tic
    self.stepTic()
555
    # check the number of lines (line1 + line2)
556
    self.assertEqual(len(self.cash_sorting.objectValues()), 7)
557 558 559 560 561 562 563 564 565
    # 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
566
    self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'unit')
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
    # 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
582 583 584 585


  def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd):
    """
586
    Check the total after the creation of the two cash sorting lines
Yoshinori Okuji's avatar
Yoshinori Okuji committed
587 588
    """
    # Check number of lines (line1 + line2)
589
    self.assertEqual(len(self.cash_sorting.objectValues()), 8)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
590
    # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
591
    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
592
    # check the total price
593
    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
594 595


596 597 598 599
  def stepConfirmCashSorting(self, sequence=None, sequence_list=None, **kwd):
    """
    Confirm the cash sorting and check it
    """
600
    self.cash_sorting.setSourceTotalAssetPrice('173400.0')
601 602 603 604 605 606 607 608
    # 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
609 610 611 612


  def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd):
    """
613
    Check that compution of inventory at vault encaisse_paris is right after confirm and before deliver
Yoshinori Okuji's avatar
Yoshinori Okuji committed
614 615
    """
    # check we have 5 banknotes of 10000 currently
616
    self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
617
    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
618
    # check we have 12 coins of 200 currently
619
    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
620
    # check we will have 0 coin of 200 after deliver
621 622 623 624
    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
625 626 627 628


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


649
  def stepDeliverCashSorting(self, sequence=None, sequence_list=None, **kwd):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
650
    """
651
    Deliver the cash sorting with a good user
Yoshinori Okuji's avatar
Yoshinori Okuji committed
652 653 654 655 656
    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"
657
    self.workflow_tool.doActionFor(self.cash_sorting, 'deliver_action', wf_id='cash_sorting_workflow')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
658 659
    # execute tic
    self.stepTic()
660 661
    # get state of cash sorting
    state = self.cash_sorting.getSimulationState()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
662 663
    # check that state is delivered
    self.assertEqual(state, 'delivered')
664

Yoshinori Okuji's avatar
Yoshinori Okuji committed
665 666 667

  def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd):
    """
668
    Check inventory at source (vault encaisse_paris) after deliver of the cash sorting
Yoshinori Okuji's avatar
Yoshinori Okuji committed
669 670
    """
    # check we have 0 banknote of 10000
671 672
    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
673
    # check we have 0 coin of 200
674 675 676 677
    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)
678 679 680
    # 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
681 682 683

  def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd):
    """
684
    Check inventory at destination (vault encaisse_aux_externe) after deliver of the cash sorting
Yoshinori Okuji's avatar
Yoshinori Okuji committed
685
    """
686 687
    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
688 689
    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)
690 691
    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)
692 693
    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
694
    # check we have 12 coins of 200
695 696
    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)
697
    # check we have 24 banknotes of 5000
698 699
    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)
700 701
    # 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
702
    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
703 704 705 706 707 708 709 710 711 712 713 714 715

  ##################################
  ##  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 ' \
716
                    + 'CreateCashSorting ' \
717
                    + 'CreateFourValidIncomingLine CheckSubTotal ' \
718 719
                    + 'CreateValidOutgoingLineForInternalBanknote ' \
                    + 'CreateValidOutgoingLineForExternalBanknote ' \
720 721 722
                    + 'CreateValidOutgoingLineForInternalAndCancelledBanknote ' \
                    + 'CreateValidOutgoingLineForMixed ' \
                    + 'Tic CheckTotal ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
723
                    + 'CheckSource CheckDestination ' \
724
                    + 'ConfirmCashSorting Tic ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
725
                    + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \
726
                    + 'DeliverCashSorting Tic ' \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
727 728 729 730 731 732 733 734 735 736 737 738 739 740
                    + '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