testERP5BankingCashClassification.py 43.4 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 34 35
##############################################################################
#
# 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.ERP5TypeTestCase import ERP5TypeTestCase
from Products.ERP5Type.tests.Sequence import SequenceList
from Products.DCWorkflow.DCWorkflow import Unauthorized, ValidationFailed
from Testing.ZopeTestCase.PortalTestCase import PortalTestCase
36
from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin
Yoshinori Okuji's avatar
Yoshinori Okuji committed
37 38 39 40 41 42 43 44 45 46 47 48

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



49
class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63

  login = PortalTestCase.login

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

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


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

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

82
    self.createFunctionGroupSiteCategory(site_list=('paris',))
83
    self.createBanknotesAndCoins()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
84 85


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

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

    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}

104 105 106 107 108 109
    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}

110

111 112 113

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

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

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


Yoshinori Okuji's avatar
Yoshinori Okuji committed
142 143 144 145 146 147 148

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


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


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


  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
193 194
    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)
195 196 197 198
    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)
199

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

208 209 210 211 212 213 214 215
    # 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)

216 217 218
    # 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)
219 220 221 222
    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
223 224


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


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

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
    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
317
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
318 319 320 321 322 323 324 325 326 327 328 329
    # 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)
330
      # check the destination vault is encaisse_aux_externe
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
      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
357
    self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'unit')
358 359 360 361 362 363 364 365 366 367 368 369
    # 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)
370
      # check the destination vault is encaisse_aux_externe
371 372 373 374 375 376 377 378 379 380
      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())

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 417 418 419
    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
420 421 422

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


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

471 472

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

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

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


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


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


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


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


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

Yoshinori Okuji's avatar
Yoshinori Okuji committed
668 669 670

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

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


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