add many comments in the test

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@5168 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/ERP5/tests/testERP5BankingCashTransfer.py

@@ -28,7 +28,7 @@
 ##############################################################################
 
 
-
+# import requested python module
 import os
 import AccessControl
 from zLOG import LOG
@@ -39,23 +39,26 @@ from Products.ERP5Type.Utils import convertToUpperCase
 from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
 from Products.ERP5Type.tests.Sequence import SequenceList
 from AccessControl.SecurityManagement import newSecurityManager
-
-
-if __name__ == '__main__':
-  execfile(os.path.join(sys.path[0], 'framework.py'))
+from Products.DCWorkflow.DCWorkflow import Unauthorized
+from Testing.ZopeTestCase.PortalTestCase import PortalTestCase
 
 # 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'
 
-
-from Products.DCWorkflow.DCWorkflow import Unauthorized
-from Testing.ZopeTestCase.PortalTestCase import PortalTestCase
+# Define how to launch the script if we don't use runUnitTest script
+if __name__ == '__main__':
+  execfile(os.path.join(sys.path[0], 'framework.py'))
 
 
 
 class TestERP5BankingCashTransfer(ERP5TypeTestCase):
   """
+    This class is a unit test to check the module of Cash Transfer
+
+    Here are the following step that will be done in the test :
+  
     - before the test, we need to create some movements that will put resources in the source
 
     - create a cash transfer
@@ -102,14 +105,14 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def getTitle(self):
     """
-      Return the title
+      Return the title of the test
     """
     return "ERP5BankingCashTransfer"
 
 
   def getBusinessTemplateList(self):
     """
-      Return the list of business templates we need
+      Return the list of business templates we need to run the test
     """
     return ( 'erp5_trade'  # erp5_trade is not required to make erp5_banking_cash_transfer working.
                            # As explained below erp5_trade is just used to help us initialize ressources
@@ -135,12 +138,18 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def afterSetUp(self):
     """
+      Method called before the test to initialize some data
     """
-    # Set variables
+    # Set some variables : 
+    # the erp5 site
     self.portal = self.getPortal()
+    # the cahs transfer module
     self.cash_transfer_module = self.getCashTransferModule()
+    # the person module
     self.person_folder = self.getPersonModule()
+    # the organisation module
     self.organisation_folder = self.getOrganisationModule()
+    # the categort tool
     self.category_tool = self.getCategoryTool()
 
     # Let us know which user folder is used
@@ -150,48 +159,85 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
     self.createManagerAndLogin()
 
     # Define static values (only use prime numbers to prevent confusions like 2 * 6 == 3 * 4)
+    # the list of years fo banknotes and coin
     self.variation_list = ('variation/1992', 'variation/2003')
+
+    # quantity of banknotes of 10000 :
     self.quantity_10000 = {}
+    # 2 banknotes of 10000 for the year 1992
     self.quantity_10000[self.variation_list[0]] = 2
+    # 3 banknotes of 10000 for the year of 2003
     self.quantity_10000[self.variation_list[1]] = 3
+
+    # quantity of coin of 200
     self.quantity_200 = {}
+    # 5 coins of 200 for the year 1992
     self.quantity_200[self.variation_list[0]] = 5
+    # 7 coins of 200 for the year 2003
     self.quantity_200[self.variation_list[1]] = 7
+
+    # quantity of banknotes of 5000
     self.quantity_5000 = {}
+    # 11 banknotes of 5000 for hte year 1992
     self.quantity_5000[self.variation_list[0]] = 11
+    # 13 banknotes of 5000 for the year 2003
     self.quantity_5000[self.variation_list[1]] = 13
 
+
     # Create Categories (vaults)
-    #self.createCategories()
+
     # as local roles are defined in portal types as real categories, we will need to reproduce (or import) the real category tree
+    # get the base category function
     self.function_base_category = getattr(self.category_tool, 'function')
+    # add category banking in function which hold all functions neccessary for bank
     self.banking = self.function_base_category.newContent(id='banking', portal_type='Category', codification='BNK')
+    # add category caisier_principal in function banking
     self.caissier_principal = self.banking.newContent(id='caissier_principal', portal_type='Category', codification='CCP')
+    # add category controleur_caisse in function banking
     self.controleur_caisse = self.banking.newContent(id='controleur_caisse', portal_type='Category', codification='CCT')
+    # add category void_function in function banking
     self.void_function = self.banking.newContent(id='void_function', portal_type='Category', codification='VOID')
+    # add category gestionnaire_caisse_courante in function banking
     self.gestionnaire_caisse_courante = self.banking.newContent(id='gestionnaire_caisse_courante', portal_type='Category', codification='CCO')
+    # add category gestionnaire_caveau in function banking
     self.gestionnaire_caveau = self.banking.newContent(id='gestionnaire_caveau', portal_type='Category', codification='CCV')
+    # add category caissier_particulier in function banking
     self.caissier_particulier = self.banking.newContent(id='caissier_particulier', portal_type='Category', codification='CGU')
 
+    # get the base category group
     self.group_base_category = getattr(self.category_tool, 'group')
+    # add the group baobab in the group category
     self.baobab = self.group_base_category.newContent(id='baobab', portal_type='Category', codification='BAOBAB')
 
+    # get the base category site
     self.site_base_category = getattr(self.category_tool, 'site')
+    # add the category testsite in the category site which hold vault situated in the bank
     self.testsite = self.site_base_category.newContent(id='testsite', portal_type='Category', codification='TEST')
+    # add vault caisse_1 in testsite
     self.caisse_1 = self.testsite.newContent(id='caisse_1', portal_type='Category', codification='C1')
+    # add vault caisse_2 in testsite
     self.caisse_2 = self.testsite.newContent(id='caisse_2', portal_type='Category', codification='C2')
 
+    # get the base category cash_status
     self.cash_status_base_category = getattr(self.category_tool, 'cash_status')
+    # add the category valid in cash_status which define status of banknotes and coin
     self.cash_status_valid = self.cash_status_base_category.newContent(id='valid', portal_type='Category')
 
+    # get the base category emission letter
     self.emission_letter_base_category = getattr(self.category_tool, 'emission_letter')
+    # add the category k in emission letter
     self.emission_letter_k = self.emission_letter_base_category.newContent(id='k', portal_type='Category')
 
+    # get the base category variation which hold the year of banknotes and coins
     self.variation_base_category = getattr(self.category_tool, 'variation')
+    # add the category 1992 in variation
     self.variation_1992 = self.variation_base_category.newContent(id='1992', portal_type='Category')
+    # add the category 2003 in varitation
     self.variation_2003 = self.variation_base_category.newContent(id='2003', portal_type='Category')
 
+    # get the base category quantity_unit
     self.variation_base_category = getattr(self.category_tool, 'quantity_unit')
+    # add category unit in quantity_unit which is the unit of banknotes and coins
     self.unit = self.variation_base_category.newContent(id='unit', title='Unit')
 
     # Create an Organisation that will be used for users assignment
@@ -208,6 +254,7 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
       , 'user_2' : [[], self.organisation, 'banking/controleur_caisse' , 'baobab', 'testsite']
       , 'user_3' : [[], self.organisation, 'banking/void_function'     , 'baobab', 'testsite']
       }
+    # call method to create this user
     self.createERP5Users(user_dict)
 
     # We must assign local roles to cash_transfer_module manually, as they are
@@ -218,37 +265,48 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
       # The group local roles must be the one for gestionnaire_caisse_courante
       self.cash_transfer_module.manage_addLocalGroupRoles('CCO_BAOBAB_TEST', ('Author',))
 
-    # Create a Currency
+    # get the currency module
     self.currency_module = self.getCurrencyModule()
+    # create the currency euro inside the currency module
     self.currency_1 = self .currency_module.newContent(id='EUR', title='Euro')
 
     # Create Resources (Banknotes)
+    # get the currency cash module
     self.currency_cash_module = self.getCurrencyCashModule()
+    # create banknote of 10000 euros from years 1992 and 2003
     self.billet_10000 = self.currency_cash_module.newContent(id='billet_10000', portal_type='Banknote', base_price=10000, price_currency_value=self.currency_1, variation_list=('1992', '2003'), quantity_unit_value=self.unit)
+    # create banknote of 500 euros from years 1992 and 2003
     self.billet_5000 = self.currency_cash_module.newContent(id='billet_5000', portal_type='Banknote', base_price=5000, price_currency_value=self.currency_1, variation_list=('1992', '2003'), quantity_unit_value=self.unit)
+    # create coin of 200 euros from years 1992 and 2003
     self.piece_200 = self.currency_cash_module.newContent(id='piece_200', portal_type='Coin', base_price=200, price_currency_value=self.currency_1, variation_list=('1992', '2003'), quantity_unit_value=self.unit)
 
     # Before the test, we need to create resources in the source.
     # Using internal_packing_list from erp5_trade is the easiest.
+    # set the type of delivery
     self.portal.portal_delivery_type_list = list(self.portal.portal_delivery_type_list)
     self.portal.portal_delivery_type_list.append('Internal Packing List')
     self.portal.portal_delivery_type_list = tuple(self.portal.portal_delivery_type_list)
+    # set the type of delivey movement
     self.portal.portal_delivery_movement_type_list = list(self.portal.portal_delivery_movement_type_list)
     self.portal.portal_delivery_movement_type_list.append('Internal Packing List Line')
     self.portal.portal_delivery_movement_type_list = tuple(self.portal.portal_delivery_movement_type_list)
-
+    # get the internal packing list module
     self.internal_packing_list_module = self.getInternalPackingListModule()
+    # add a new packing list for caisse_1
     self.internal_packing_list = self.internal_packing_list_module.newContent(id='packing_list_1', portal_type='Internal Packing List',
             source=None, destination_value=self.caisse_1)
+    # add banknotes of 10000 with emission letter k, status valid and from years 1992 and 2003 with the quantity defined before in quantity_10000 (2 for 1992 and 3 for 2003)
     self.addCashLineToDelivery(self.internal_packing_list, 'delivery_init_1', 'Internal Packing List Line', self.billet_10000,
             ('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/valid') + self.variation_list,
             self.quantity_10000)
+    # add coins of 200 with emission letter k, status valid and from years 1992 and 2003 with the quantity defined before in quantity_200 (5 for 1992 and 7 for 2003)
     self.addCashLineToDelivery(self.internal_packing_list, 'delivery_init_2', 'Internal Packing List Line', self.piece_200,
             ('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/valid') + self.variation_list,
             self.quantity_200)
 
-    # Finally, login as user_1
+    # logout from manager
     self.logout()
+    # Finally, login as user_1
     self.login('user_1')
 
 
@@ -259,6 +317,7 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
     self.user_folder = self.getUserFolder()
     self.PAS_installed = 0
     if self.user_folder.meta_type == 'Pluggable Auth Service':
+      # we use PAS
       self.PAS_installed = 1
 
 
@@ -326,15 +385,19 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
   def addCashLineToDelivery(self, delivery_object, line_id, line_portal_type, resource_object,
           variation_base_category_list, variation_category_list, resource_quantity_dict):
     """
+    Add a cash line to a delivery
     """
     base_id = 'movement'
     line_kwd = {'base_id':base_id}
+    # create the line
     line = delivery_object.newContent( id                  = line_id
                                      , portal_type         = line_portal_type
-                                     , resource_value      = resource_object
+                                     , resource_value      = resource_object # banknote or coin
                                      , quantity_unit_value = self.unit
                                      )
+    # set base cateogy list
     line.setVariationBaseCategoryList(variation_base_category_list)
+    # set category
     line.setVariationCategoryList(variation_category_list)
     line.updateCellRange(script_id='CashDetail_asCellRange', base_id=base_id)
     cell_range_key_list = line.getCellRangeKeyList(base_id=base_id)
@@ -348,42 +411,70 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
               , category_list                      = category_list
               , force_update                       = 1
               )
+    # set quantity on cell
     for variation in self.variation_list:
       cell = line.getCell('emission_letter/k', variation, 'cash_status/valid')
       cell.setQuantity(resource_quantity_dict[variation])
-#       cell.setResourceValue(resource_object)
-#       cell.setDestinationValue(self.caisse_1)
-#       LOG("XXX set Resource Value >>>>>>",0, repr(resource_object))
-#       LOG("XXX set Destination Value >>>>>>",0, repr(self.caisse_1))
-#       LOG("XXX get Destination Value On Cell >>>>>>",0, repr(cell))
-#       LOG("XXX get Destination Value >>>>>>",0, repr(cell.getDestinationValue()))
-#       LOG("XXX get Baobab Destination Value >>>>>>",0, repr(cell.getBaobabDestinationValue()))
-#       LOG("XXX get Destination UID >>>>>>",0, repr(cell.getDestinationUid()))
-#       LOG("XXX get Baobab Destination UID >>>>>>",0, repr(cell.getBaobabDestinationUid()))
-#       LOG("XXX getBaobabDestinationUID func >>>>>>",0, repr(getattr(cell, 'getBaobabDestinationUid', None)))
-#       LOG("XXX func dict >>>>>>",0, repr(getattr(cell, 'getBaobabDestinationUid', None).__dict__))
-#       LOG("XXX func module >>>>>>",0, repr(getattr(cell, 'getBaobabDestinationUid', None).__module__))
 
 
   def getUserFolder(self):
+    """
+    Return the user folder
+    """
     return getattr(self.getPortal(), 'acl_users', None)
+
   def getPersonModule(self):
+    """
+    Return the person module
+    """
     return getattr(self.getPortal(), 'person_module', None)
+  
   def getOrganisationModule(self):
+    """
+    Return the organisation module
+    """
     return getattr(self.getPortal(), 'organisation_module', None)
+  
   def getCurrencyCashModule(self):
+    """
+    Return the Currency Cash Module
+    """
     return getattr(self.getPortal(), 'currency_cash_module', None)
+  
   def getCashTransferModule(self):
+    """
+    Return the Cash Transer Module
+    """
     return getattr(self.getPortal(), 'cash_transfer_module', None)
+  
   def getInternalPackingListModule(self):
+    """
+    Return the Internal Packing List Module
+    """
     return getattr(self.getPortal(), 'internal_packing_list_module', None)
+  
   def getCurrencyModule(self):
+    """
+    Return the Currency Module
+    """
     return getattr(self.getPortal(), 'currency_module', None)
+  
   def getCategoryTool(self):
+    """
+    Return the Category Tool
+    """
     return getattr(self.getPortal(), 'portal_categories', None)
+  
   def getWorkflowTool(self):
+    """
+    Return the Worklfow Tool
+    """
     return getattr(self.getPortal(), 'portal_workflow', None)
+  
   def getSimulationTool(self):
+    """
+    Return the Simulation Tool
+    """
     return getattr(self.getPortal(), 'portal_simulation', None)
 
 
@@ -394,6 +485,7 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepTic(self, **kwd):
     """
+    The is used to simulate the zope_tic_loop script
     """
     self.tic()
 
@@ -408,23 +500,36 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
     self.assertEqual(self.caisse_1.getPortalType(), 'Category')
     self.assertEqual(self.caisse_2.getPortalType(), 'Category')
     # check that Resources were created
+    # check portal type of billet_10000
     self.assertEqual(self.billet_10000.getPortalType(), 'Banknote')
+    # check value of billet_10000
     self.assertEqual(self.billet_10000.getBasePrice(), 10000)
+    # check currency value  of billet_10000
     self.assertEqual(self.billet_10000.getPriceCurrency(), 'currency_module/EUR')
+    # check years  of billet_10000
     self.assertEqual(self.billet_10000.getVariationList(), ['1992', '2003'])
 
+    # check portal type of billet_5000
     self.assertEqual(self.billet_5000.getPortalType(), 'Banknote')
+    # check value of billet_5000
     self.assertEqual(self.billet_5000.getBasePrice(), 5000)
+    # check currency value  of billet_5000
     self.assertEqual(self.billet_5000.getPriceCurrency(), 'currency_module/EUR')
+    # check years  of billet_5000
     self.assertEqual(self.billet_5000.getVariationList(), ['1992', '2003'])
     
+    # check portal type of piece_200
     self.assertEqual(self.piece_200.getPortalType(), 'Coin')
+    # check value of piece_200
     self.assertEqual(self.piece_200.getBasePrice(), 200)
+    # check currency value  of piece_200
     self.assertEqual(self.piece_200.getPriceCurrency(), 'currency_module/EUR')
+    # check years  of piece_200
     self.assertEqual(self.piece_200.getVariationList(), ['1992', '2003'])
 
     # check that CashTransfer Module was created
     self.assertEqual(self.cash_transfer_module.getPortalType(), 'Cash Transfer Module')
+    # check cash transfer module is empty
     self.assertEqual(len(self.cash_transfer_module.objectValues()), 0)
 
 
@@ -433,37 +538,51 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
     Check the initial inventory.
     """
     self.simulation_tool = self.getSimulationTool()
+    # check we have 5 banknotes of 10000
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
+    # check we have 12 coin of 200
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
 
 
   def stepCheckSource(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check inventory in source vault
     """
+    # check we have 5 banknotes of 10000
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
+    # check we have 12 coin of 200
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
 
 
   def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check inventory in destination vault
     """
+    # check we don't have banknotes of 10000
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
+    # check we don't have coins of 200
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
 
 
   def stepCheckCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check data in the cash transfer
     """
+    # check wehave only one cash transfer
     self.assertEqual(len(self.cash_transfer_module.objectValues()), 1)
+    # get the cash transfer
     self.cash_transfer = getattr(self.cash_transfer_module, 'cash_transfer_1')
+    # check its portal type
     self.assertEqual(self.cash_transfer.getPortalType(), 'Cash Transfer')
+    # check its source
     self.assertEqual(self.cash_transfer.getSource(), 'site/testsite/caisse_1')
+    # check its destination
     self.assertEqual(self.cash_transfer.getDestination(), 'site/testsite/caisse_2')
     #XXX Check roles were correctly affected
     #self.security_manager = AccessControl.getSecurityManager()
@@ -473,23 +592,38 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepCheckValidLine1(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the valid line as been well created
     """
+    # check there is only one line
     self.assertEqual(len(self.cash_transfer.objectValues()), 1)
+    # get the line
     self.valid_line_1 = getattr(self.cash_transfer, 'valid_line_1')
+    # check portal type
     self.assertEqual(self.valid_line_1.getPortalType(), 'Cash Transfer Line')
+    # check the resource is banknotes of 10000
     self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_10000)
+    # chek the value of the banknote
     self.assertEqual(self.valid_line_1.getPrice(), 10000.0)
+    # check the unit of banknote
     self.assertEqual(self.valid_line_1.getQuantityUnit(), 'quantity_unit/unit')
+    # check we have two cells: (one for year 1992 and one for 2003)
     self.assertEqual(len(self.valid_line_1.objectValues()), 2)
     for variation in self.variation_list:
+      # get the cell
       cell = self.valid_line_1.getCell('emission_letter/k', variation, 'cash_status/valid')
+      # chek portal types
       self.assertEqual(cell.getPortalType(), 'Delivery Cell')
-      if cell.getId() == 'movement_0_0_0':
-        self.assertEqual(cell.getQuantity(), 2.0)
+      # check the banknote of the cell is banknote of 10000
       self.assertEqual(cell.getResourceValue(), self.billet_10000)
+      # check the source vault is caisse_1
       self.assertEqual(cell.getSourceValue(), self.caisse_1)
+      # check the destination vault is caisse_2
       self.assertEqual(cell.getDestinationValue(), self.caisse_2)
+      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())
@@ -497,29 +631,44 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the amount after the creation of line 1
     """
     # Check number of lines
     self.assertEqual(len(self.cash_transfer.objectValues()), 1)
-    # Check sum
+    # Check quantity of banknotes (2 for 1992 and 3 for 2003)
     self.assertEqual(self.cash_transfer.getTotalQuantity(), 5.0)
+    # Check the total price
     self.assertEqual(self.cash_transfer.getTotalPrice(), 10000 * 5.0)
 
 
   def stepCheckValidLine2(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the line 2 has been well created
     """
+    # check the number of lines (line1 + line2)
     self.assertEqual(len(self.cash_transfer.objectValues()), 2)
+    # get the second line
     self.valid_line_2 = getattr(self.cash_transfer, 'valid_line_2')
+    # check portal types
     self.assertEqual(self.valid_line_2.getPortalType(), 'Cash Transfer Line')
+    # check the resource is coin of 200
     self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200)
+    # check the value
     self.assertEqual(self.valid_line_2.getPrice(), 200.0)
+    # check the unit
     self.assertEqual(self.valid_line_2.getQuantityUnit(), 'quantity_unit/unit')
+    # check we have two cells: (one for year 1992 and one for 2003)
+    self.assertEqual(len(self.valid_line_2.objectValues()), 2)
     for variation in self.variation_list:
+      # get the cell
       cell = self.valid_line_2.getCell('emission_letter/k', variation, 'cash_status/valid')
+      # check the portal type
       self.assertEqual(cell.getPortalType(), 'Delivery 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())
@@ -527,114 +676,162 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the total after the creation of the two lines
     """
-    # Check number of lines
+    # Check number of lines (line1 + line2)
     self.assertEqual(len(self.cash_transfer.objectValues()), 2)
-    # Check sum
+    # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
     self.assertEqual(self.cash_transfer.getTotalQuantity(), 5.0 + 12.0)
+    # check the total price
     self.assertEqual(self.cash_transfer.getTotalPrice(), 10000 * 5.0 + 200 * 12.0)
 
 
   def stepCheckBadTotal(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the total with the invalid line
     """
     # Check number of lines
     self.assertEqual(len(self.cash_transfer.objectValues()), 3)
-    # Check sum
+    # Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003
     self.assertEqual(self.cash_transfer.getTotalQuantity(), 5.0 + 12.0 + 24)
+    # chect the total price
     self.assertEqual(self.cash_transfer.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24)
 
 
   def stepCheckBadUserConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check that the try of confirm by a bad user doesn't change the cahs transfer
     """
+    # get state of cash transfer
     state = self.cash_transfer.getSimulationState()
+    # check it has remain as draft
     self.assertEqual(state, 'draft')
+    # get the workflow history
     workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_transfer, name='history', wf_id='cash_transfer_workflow')
+    # check its len is one
     self.assertEqual(len(workflow_history), 1)
 
 
   def stepCheckBadInventoryConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the try of confirm the cash transfer with the invalid line
     """
+    # get state
     state = self.cash_transfer.getSimulationState()
+    # check state is draft
     self.assertEqual(state, 'draft')
+    # get workflow history
     workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_transfer, name='history', wf_id='cash_transfer_workflow')
+    # check len is 2
     self.assertEqual(len(workflow_history), 2)
+    # check we get an "Insufficient balance" message in the workflow history
     self.assertEqual('Insufficient balance' in workflow_history[-1]['error_message'], True)
 
 
   def stepCheckConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the confirm the cash transfer
     """
+    # get state
     state = self.cash_transfer.getSimulationState()
+    # check state is confirmed
     self.assertEqual(state, 'confirmed')
+    # get workflow history
     workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_transfer, name='history', wf_id='cash_transfer_workflow')
+    # check  len of workflow history is 4
     self.assertEqual(len(workflow_history), 4)
 
 
   def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check that compution of inventory at vault caisse_1 is well before deliver
     """
+    # check we have 5 banknotes of 10000 currently
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
+    # check we will have 0 banknote of 10000 after deliver
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
+    # check we have 12 coins of 200 currently
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
+    # check we will have 0 coin of 200 after deliver
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
 
 
   def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check that compution of inventory at vault caisse_2 is well before deliver
     """
+    # check we have 0 banknote of 10000 currently
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
+    # check we will have 5 banknotes of 10000 after deliver
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
+    # check we have 0 coin of 200 currently
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
+    # check we will have 12 coins of 200 after deliver
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
 
 
   def stepBadUserCheckDeliverCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check that the try to deliver Cash Transfer with a bad user have failed
     """
+    # get state
     state = self.cash_transfer.getSimulationState()
+    # check state is confirmed
     self.assertEqual(state, 'confirmed')
+    # get workflow history
     workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_transfer, name='history', wf_id='cash_transfer_workflow')
+    # check len of workflow history is 4
     self.assertEqual(len(workflow_history), 4)
 
 
   def stepCheckDeliverCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check the deliver of a cash tranfer have achieved
     """
+    # get state
     state = self.cash_transfer.getSimulationState()
+    # check state is deliver
     self.assertEqual(state, 'delivered')
+    # get workflow history
     workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_transfer, name='history', wf_id='cash_transfer_workflow')
+    # check len of len workflow history is 6
     self.assertEqual(len(workflow_history), 6)
 
 
   def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check inventory at source (vault caisse_1) after deliver of cash transfer
     """
+    # check we have 0 banknote of 10000
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
+    # check we have 0 coin of 200
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_1.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
 
 
   def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd):
     """
+    Check inventory at destination (vault caisse_2) after deliver of cash transfer
     """
+    # check we have 5 banknotes of 10000
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
+    # check we have 12 coins of 200
     self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
     self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_2.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0)
 
 
   def stepCreateCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Create a cash transfer
     """
     self.cash_transfer = self.cash_transfer_module.newContent(id='cash_transfer_1', portal_type='Cash Transfer', source_value=self.caisse_1, destination_value=self.caisse_2, price=52400.0) # 5 * 1000 + 12 * 200
 
 
   def stepCreateValidLine1(self, sequence=None, sequence_list=None, **kwd):
     """
+    Create the line 1 with banknotes of 10000
     """
     self.addCashLineToDelivery(self.cash_transfer, 'valid_line_1', 'Cash Transfer Line', self.billet_10000,
             ('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/valid') + self.variation_list,
@@ -643,6 +840,7 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepCreateValidLine2(self, sequence=None, sequence_list=None, **kwd):
     """
+    Create the line 2 wiht coins of 200
     """
     self.addCashLineToDelivery(self.cash_transfer, 'valid_line_2', 'Cash Transfer Line', self.piece_200,
             ('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/valid') + self.variation_list,
@@ -651,7 +849,10 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd):
     """
+    Create an invalid line
     """
+    # create a line in which quanity of banknotes of 5000 is higher that quantity available at source
+    # here create a line with 24 (11+13) banknotes of 500 although the vault caisse_1 has no banknote of 5000
     self.addCashLineToDelivery(self.cash_transfer, 'invalid_line', 'Cash Transfer Line', self.billet_5000,
             ('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/valid') + self.variation_list,
             self.quantity_5000)
@@ -659,66 +860,76 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd):
     """
+    Delete the invalid line previously create
     """
     self.cash_transfer.deleteContent('invalid_line')
 
 
   def stepBadUserConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Try to confirm cash transfer with a user that doesn't have the right
     """
-    # log in as bad user
+    # logout from user_1
     self.logout()
+    # log in as bad user
     self.login('user_3')
     # try to doActionFor
     self.workflow_tool = self.getWorkflowTool()
+    # check that an nauthorized exception is raised
     self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.cash_transfer, 'confirm_action', wf_id='cash_transfer_workflow')
-    # log in as default user
+    # logout from user_3
     self.logout()
+    # login as default user
     self.login('user_1')
 
 
   def stepBadInventoryConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Try to confirm thre cash transfer with a bad line
     """
-    # fix amount
+    # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24)
     self.cash_transfer.setPrice('172400.0')
-    # logged in as good user
-    # try to doActionFor
+    # try to do the workflow action
     self.workflow_tool.doActionFor(self.cash_transfer, 'confirm_action', wf_id='cash_transfer_workflow')
 
 
   def stepConfirmCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Confir the cash transfer
     """
-    # fix amount
+    # fix amount (10000 * 5.0 + 200 * 12.0)
     self.cash_transfer.setPrice('52400.0')
-    # logged in as good user
-    # try to doActionFor
+    # do the orkflow action
     self.workflow_tool.doActionFor(self.cash_transfer, 'confirm_action', wf_id='cash_transfer_workflow')
 
 
   def stepBadUserDeliverCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Try to deliver a cash transfer with a user that don't have the right
     """
-    # log in as bad user
+    # logout from user_1
     self.logout()
+    # log in as bad user
     self.login('user_3')
-    # try to doActionFor
+    # check we raise an Unauthorized Exception if we try to deliver cash transfer
     self.assertRaises(Unauthorized, self.workflow_tool.doActionFor, self.cash_transfer, 'deliver_action', wf_id='cash_transfer_workflow')
-    # log in as default user
+    # logout from bad user
     self.logout()
+    # log in as default user
     self.login('user_1')
     
 
   def stepDeliverCashTransfer(self, sequence=None, sequence_list=None, **kwd):
     """
+    Deliver the cash transfer with a good user
     """
-    # log in as good user
+    # logout from user_1
     self.logout()
+    # log in as good user (controleur_caisse)
     self.login('user_2')
-    # try to doActionFor
-    self.security_manager = AccessControl.getSecurityManager()
-    self.user = self.security_manager.getUser()
+    #     self.security_manager = AccessControl.getSecurityManager()
+    #     self.user = self.security_manager.getUser()
+    # do the workflow transition "deliver_action"
     self.workflow_tool.doActionFor(self.cash_transfer, 'deliver_action', wf_id='cash_transfer_workflow')
     # log in as default user
     self.logout()
@@ -732,10 +943,11 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
 
   def test_01_ERP5BankingCashTransfer(self, quiet=QUIET, run=RUN_ALL_TEST):
     """
-      We'll play the sequence
+    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' \
                     + ' CreateCashTransfer Tic CheckCashTransfer' \
                     + ' CreateValidLine1 Tic CheckValidLine1 CheckSubTotal' \
@@ -752,11 +964,10 @@ class TestERP5BankingCashTransfer(ERP5TypeTestCase):
                     + ' DeliverCashTransfer Tic CheckDeliverCashTransfer' \
                     + ' 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: