Skip to content

erp5
erp5
Commit c4cd2aea authored by Aurel's avatar Aurel
Browse files
Options

add unit test for cash sorting module and rewrite the one for classification... 

add unit test for cash sorting module and rewrite the one for classification to use cash sorting module


git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@6984 20353a03-c40f-0410-a6d1-a30d3c3de9de
parent 42dec33d
Hide whitespace changes
Inline Side-by-side
Showing with 1004 additions and 156 deletions
product/ERP5Banking/tests/testERP5BankingCashClassification.py
View file @ c4cd2aea
...@@ -72,14 +72,14 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -72,14 +72,14 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
return ( 'erp5_base' return ( 'erp5_base'
, 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking , 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking
, 'erp5_banking_inventory' , 'erp5_banking_inventory'
, 'erp5_banking_cash' # erp5_banking_cash contains all method for cash classification , 'erp5_banking_cash' # erp5_banking_cash contains all method for cash sorting
) )
def getCashClassificationModule(self): def getCashSortingModule(self):
""" """
Return the Cash Classification Module Return the Cash Sorting Module
""" """
return getattr(self.getPortal(), 'cash_classification_module', None) return getattr(self.getPortal(), 'cash_sorting_module', None)
def afterSetUp(self): def afterSetUp(self):
...@@ -87,8 +87,8 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -87,8 +87,8 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
Method called before the launch of the test to initialize some data Method called before the launch of the test to initialize some data
""" """
self.initDefaultVariable() self.initDefaultVariable()
# Set some variables : # Set some variables :
self.cash_classification_module = self.getCashClassificationModule() self.cash_sorting_module = self.getCashSortingModule()
# Create a user and login as manager to populate the erp5 portal with objects for tests. # Create a user and login as manager to populate the erp5 portal with objects for tests.
self.createManagerAndLogin() self.createManagerAndLogin()
...@@ -100,18 +100,47 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -100,18 +100,47 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
inventory_dict_line_1 = {'id' : 'inventory_line_1', inventory_dict_line_1 = {'id' : 'inventory_line_1',
'resource': self.billet_10000, 'resource': self.billet_10000,
'variation_id': ('emission_letter', 'cash_status', 'variation'), 'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/k', 'cash_status/to_sort') + self.variation_list, 'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
'quantity': self.quantity_10000} 'quantity': self.quantity_10000}
inventory_dict_line_2 = {'id' : 'inventory_line_2', inventory_dict_line_2 = {'id' : 'inventory_line_2',
'resource': self.billet_200, 'resource': self.billet_200,
'variation_id': ('emission_letter', 'cash_status', 'variation'), 'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/b', 'cash_status/to_sort') + self.variation_list, 'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
'quantity': self.quantity_200} 'quantity': self.quantity_200}
line_list = [inventory_dict_line_1, inventory_dict_line_2]
self.createCashInventory(source=None, destination=self.caisse_lille, currency=self.currency_1, 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}
line_list = [inventory_dict_line_1, inventory_dict_line_2, inventory_dict_line_3]
self.encaisse_tri = self.paris.surface.salle_de_tri.encaisse_des_billets_recus_pour_ventilation.Spain
self.encaisse_reserve = self.paris.caveau.reserve.encaisse_des_billets_et_monnaies
self.encaisse_externe = self.paris.caveau.externes.encaisse_des_externes
self.encaisse_auxiliaire = self.paris.caveau.auxiliaire.encaisse_des_billets_recus_pour_ventilation.Spain
self.createCashInventory(source=None, destination=self.encaisse_tri, currency=self.currency_1,
line_list=line_list) line_list=line_list)
# 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')
def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd):
""" """
...@@ -120,10 +149,10 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -120,10 +149,10 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
on are really here. on are really here.
""" """
self.checkResourceCreated() self.checkResourceCreated()
# check that CashClassification Module was created # check that CashSorting Module was created
self.assertEqual(self.cash_classification_module.getPortalType(), 'Cash Classification Module') self.assertEqual(self.cash_sorting_module.getPortalType(), 'Cash Sorting Module')
# check cash classification module is empty # check cash sorting module is empty
self.assertEqual(len(self.cash_classification_module.objectValues()), 0) self.assertEqual(len(self.cash_sorting_module.objectValues()), 0)
def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd):
...@@ -131,24 +160,28 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -131,24 +160,28 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
Check the initial inventory before any operations Check the initial inventory before any operations
""" """
self.simulation_tool = self.getSimulationTool() self.simulation_tool = self.getSimulationTool()
# check we have 5 banknotes of 10000 in caisse_lille # check we have 5 banknotes of 10000 in encaisse_paris
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) 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.caisse_lille.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)
# check we have 12 coin of 200 in caisse_lille # check we have 12 coin of 200 in encaisse_paris
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) 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.caisse_lille.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)
def stepCheckSource(self, sequence=None, sequence_list=None, **kwd): def stepCheckSource(self, sequence=None, sequence_list=None, **kwd):
""" """
Check inventory in source vault (caisse_lille) before a confirm Check inventory in source vault (encaisse_paris) before a confirm
""" """
# check we have 5 banknotes of 10000 # check we have 5 banknotes of 10000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) 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.caisse_lille.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)
# check we have 12 coin of 200 # check we have 12 coin of 200
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) 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.caisse_lille.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)
def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd): def stepCheckDestination(self, sequence=None, sequence_list=None, **kwd):
...@@ -156,49 +189,66 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -156,49 +189,66 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
Check inventory in destination vault (caisse_2) before confirm Check inventory in destination vault (caisse_2) before confirm
""" """
# check we don't have banknotes of 10000 # check we don't have banknotes of 10000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_billets_et_monnaies.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) 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_billets_et_monnaies.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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
# check we don't have coins of 200 # check we don't have coins of 200
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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
# 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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
def stepCreateCashClassification(self, sequence=None, sequence_list=None, **kwd): def stepCreateCashSorting(self, sequence=None, sequence_list=None, **kwd):
""" """
Create a cash classification document and check it Create a cash sorting document and check it
""" """
# Cash classification has caisse_lille for source, encaisse_externe for destination, and a price cooreponding to the sum of banknote of 10000 and banknotes of 200 ( (2+3) * 1000 + (5+7) * 200 ) # Cash sorting has encaisse_paris for source, encaisse_externe for destination, and a price cooreponding to the sum of banknote of 10000 and banknotes of 200 ( (2+3) * 1000 + (5+7) * 200 )
self.cash_classification = self.cash_classification_module.newContent(id='cash_classification_1', portal_type='Cash Classification', source_value=self.caisse_lille, destination_value=None, source_total_asset_price=52400.0) self.cash_sorting = self.cash_sorting_module.newContent(id='cash_sorting_1', portal_type='Cash Sorting', source_value=self.encaisse_tri, destination_value=None, source_total_asset_price=52400.0)
# execute tic # execute tic
self.stepTic() self.stepTic()
# check we have only one cash classification # check we have only one cash sorting
self.assertEqual(len(self.cash_classification_module.objectValues()), 1) self.assertEqual(len(self.cash_sorting_module.objectValues()), 1)
# get the cash classification document # get the cash sorting document
self.cash_classification = getattr(self.cash_classification_module, 'cash_classification_1') self.cash_sorting = getattr(self.cash_sorting_module, 'cash_sorting_1')
# check its portal type # check its portal type
self.assertEqual(self.cash_classification.getPortalType(), 'Cash Classification') self.assertEqual(self.cash_sorting.getPortalType(), 'Cash Sorting')
# check that its source is caisse_lille # check that its source is encaisse_paris
self.assertEqual(self.cash_classification.getSource(), 'site/testsite/encaisse_des_billets_recus_pour_ventilation/lille') self.assertEqual(self.cash_sorting.getSource(), 'site/testsite/paris/surface/salle_de_tri/encaisse_des_billets_recus_pour_ventilation/Spain')
# check that its destination is encaisse_externe # check that its destination is encaisse_externe
self.assertEqual(self.cash_classification.getDestination(), None) self.assertEqual(self.cash_sorting.getDestination(), None)
def stepCreateValidIncomingLine(self, sequence=None, sequence_list=None, **kwd): def stepCreateThreeValidIncomingLine(self, sequence=None, sequence_list=None, **kwd):
""" """
Create the cash classification incoming line with banknotes of 10000 and check it has been well created Create the cash sorting incoming line with banknotes of 10000 and check it has been well created
""" """
# create the cash classification line # create the cash sorting line
self.addCashLineToDelivery(self.cash_classification, 'valid_incoming_line', 'Incoming Cash Classification Line', self.billet_10000, self.addCashLineToDelivery(self.cash_sorting, 'valid_incoming_line_1', 'Incoming Cash Sorting Line', self.billet_10000,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/to_sort') + self.variation_list, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
self.quantity_10000) self.quantity_10000)
# execute tic # execute tic
self.stepTic() self.stepTic()
# check there is only one line created # check there is only one line created
self.assertEqual(len(self.cash_classification.objectValues()), 1) self.assertEqual(len(self.cash_sorting.objectValues()), 1)
# get the cash classification line # get the cash sorting line
self.valid_incoming_line = getattr(self.cash_classification, 'valid_incoming_line') self.valid_incoming_line = getattr(self.cash_sorting, 'valid_incoming_line_1')
# check its portal type # check its portal type
self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Classification Line') self.assertEqual(self.valid_incoming_line.getPortalType(), 'Incoming Cash Sorting Line')
# check the resource is banknotes of 10000 # check the resource is banknotes of 10000
self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_10000) self.assertEqual(self.valid_incoming_line.getResourceValue(), self.billet_10000)
# chek the value of the banknote # chek the value of the banknote
...@@ -210,13 +260,13 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -210,13 +260,13 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
# now check for each variation (years 1992 and 2003) # now check for each variation (years 1992 and 2003)
for variation in self.variation_list: for variation in self.variation_list:
# get the delivery cell # get the delivery cell
cell = self.valid_incoming_line.getCell('emission_letter/k', variation, 'cash_status/to_sort') cell = self.valid_incoming_line.getCell('emission_letter/not_defined', variation, 'cash_status/to_sort')
# chek portal types # chek portal types
self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
# check the banknote of the cell is banknote of 10000 # check the banknote of the cell is banknote of 10000
self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getResourceValue(), self.billet_10000)
# check the source vault is caisse_lille # check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.caisse_lille) self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_externe # check the destination vault is encaisse_externe
self.assertEqual(cell.getDestinationValue(), None) self.assertEqual(cell.getDestinationValue(), None)
if cell.getId() == 'movement_0_0_0': if cell.getId() == 'movement_0_0_0':
...@@ -228,152 +278,281 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -228,152 +278,281 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
else: else:
self.fail('Wrong cell created : %s' % cell.getId()) self.fail('Wrong cell created : %s' % cell.getId())
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
self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'quantity_unit/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_200)
# check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_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(), 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
self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'quantity_unit/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_5000)
# check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_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(), 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())
def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd): def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the amount after the creation of cash classification line 1 Check the amount after the creation of cash sorting line 1
""" """
# Check number of lines # Check number of lines
self.assertEqual(len(self.cash_classification.objectValues()), 1) self.assertEqual(len(self.cash_sorting.objectValues()), 3)
# Check quantity of banknotes (2 for 1992 and 3 for 2003) # Check quantity of banknotes (2 for 1992 and 3 for 2003)
self.assertEqual(self.cash_classification.getTotalQuantity(), 5.0) self.assertEqual(self.cash_sorting.getTotalQuantity(deliveryLineType="Incoming Cash Sorting Line"), 41.0)
# Check the total price # Check the total price
self.assertEqual(self.cash_classification.getTotalPrice(), 10000 * 5.0) self.assertEqual(self.cash_sorting.getTotalPrice(deliveryLineType="Incoming Cash Sorting Line"), 10000 * 5.0 + 200 * 12.0 + 5000 * 24.0)
def stepCreateValidOutgoingLine(self, sequence=None, sequence_list=None, **kwd): def stepCreateValidOutgoingLineForInternalBanknote(self, sequence=None, sequence_list=None, **kwd):
""" """
Create the cash classification outgoing line wiht banknotes of 200 and check it has been well created Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
""" """
# create the line # create the line
self.addCashLineToDelivery(self.cash_classification, 'valid_outgoing_line', 'Outgoing Cash Classification Line', self.billet_200, self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_1', 'Outgoing Cash Sorting Line', self.billet_10000,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/b', 'cash_status/to_sort') + self.variation_list, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list,
self.quantity_200) self.quantity_10000)
# execute tic # execute tic
self.stepTic() self.stepTic()
# check the number of lines (line1 + line2) # check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_classification.objectValues()), 2) self.assertEqual(len(self.cash_sorting.objectValues()), 4)
# get the second cash classification line # get the second cash sorting line
self.valid_outgoing_line = getattr(self.cash_classification, 'valid_outgoing_line') self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_1')
# check portal types # check portal types
self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Classification Line') self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
# check the resource is coin of 200 # check the resource is coin of 200
self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_200) self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_10000)
# check the value of coin # check the value of coin
self.assertEqual(self.valid_outgoing_line.getPrice(), 200.0) self.assertEqual(self.valid_outgoing_line.getPrice(), 10000.0)
# check the unit of coin # check the unit of coin
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/unit') self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/unit')
# check we have two delivery cells: (one for year 1992 and one for 2003) # check we have two delivery cells: (one for year 1992 and one for 2003)
self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2) self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
for variation in self.variation_list: for variation in self.variation_list:
# get the delivery cell # get the delivery cell
cell = self.valid_outgoing_line.getCell('emission_letter/b', variation, 'cash_status/to_sort') cell = self.valid_outgoing_line.getCell('emission_letter/p', variation, 'cash_status/valid')
# check the portal type # check the portal type
self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getPortalType(), 'Outgoing Cash Sorting Cell')
if cell.getId() == 'movement_0_0_0': if cell.getId() == 'movement_0_0_0':
# check the quantity for coin for year 1992 is 5 # check the quantity for coin for year 1992 is 5
self.assertEqual(cell.getQuantity(), 5.0) self.assertEqual(cell.getQuantity(), 2.0)
elif cell.getId() == 'movement_0_1_0': elif cell.getId() == 'movement_0_1_0':
# check the quantity for coin for year 2003 is 7 # check the quantity for coin for year 2003 is 7
self.assertEqual(cell.getQuantity(), 7.0) self.assertEqual(cell.getQuantity(), 3.0)
else: else:
self.fail('Wrong cell created : %s' % cell.getId()) self.fail('Wrong cell created : %s' % cell.getId())
def stepCreateInvalidLine(self, sequence=None, sequence_list=None, **kwd): def stepCreateValidOutgoingLineForExternalBanknote(self, sequence=None, sequence_list=None, **kwd):
""" """
Create an invalid cash classification line and Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
check the total with the invalid cash classification line
""" """
# create a line in which quanity of banknotes of 5000 is higher that quantity available at source # create the line
# here create a line with 24 (11+13) banknotes of 500 although the vault caisse_lille has no banknote of 5000 self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_2', 'Outgoing Cash Sorting Line', self.billet_200,
self.addCashLineToDelivery(self.cash_classification, 'invalid_line', 'Outgoing Cash Classification Line', self.billet_5000, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/s', 'cash_status/valid') + self.variation_list,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/k', 'cash_status/to_sort') + self.variation_list, self.quantity_200)
self.quantity_5000)
# execute tic # execute tic
self.stepTic() self.stepTic()
# Check number of cash classification lines (line1 + line2 +invalid_line) # check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_classification.objectValues()), 3) self.assertEqual(len(self.cash_sorting.objectValues()), 5)
# Check quantity, same as checkTotal + banknote of 500: 11 for 1992 and 13 for 2003 # get the second cash sorting line
self.assertEqual(self.cash_classification.getTotalQuantity(), 5.0 + 12.0 + 24) self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_2')
# chect the total price # check portal types
self.assertEqual(self.cash_classification.getTotalPrice(), 10000 * 5.0 + 200 * 12.0 + 5000 * 24) 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
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/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
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())
def stepTryConfirmCashClassificationWithBadInventory(self, sequence=None, sequence_list=None, **kwd): def stepCreateValidOutgoingLineForInternalAndCancelledBanknote(self, sequence=None, sequence_list=None, **kwd):
""" """
Try to confirm the cash classification with a bad cash classification line and Create the cash sorting outgoing line wiht banknotes of 200 and check it has been well created
check the try of confirm the cash classification with the invalid line has failed
""" """
# fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24) # create the line
self.cash_classification.setSourceTotalAssetPrice('172400.0') self.addCashLineToDelivery(self.cash_sorting, 'valid_outgoing_line_3', 'Outgoing Cash Sorting Line', self.billet_5000,
# try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/cancelled') + self.variation_list,
self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.cash_classification, 'confirm_action', wf_id='cash_classification_workflow') self.quantity_5000)
# execute tic # execute tic
self.stepTic() self.stepTic()
# get state of the cash classification # check the number of lines (line1 + line2)
state = self.cash_classification.getSimulationState() self.assertEqual(len(self.cash_sorting.objectValues()), 6)
# check the state is draft # get the second cash sorting line
self.assertEqual(state, 'draft') self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_3')
# get workflow history # check portal types
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_classification, name='history', wf_id='cash_classification_workflow') self.assertEqual(self.valid_outgoing_line.getPortalType(), 'Outgoing Cash Sorting Line')
# check its len is 2 # check the resource is coin of 200
self.assertEqual(len(workflow_history), 2) self.assertEqual(self.valid_outgoing_line.getResourceValue(), self.billet_5000)
msg = workflow_history[-1]['error_message'] # check the value of coin
self.assertEqual('Insufficient Balance.' , "%s" %(msg,)) self.assertEqual(self.valid_outgoing_line.getPrice(), 5000.0)
# check the unit of coin
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/unit')
def stepDelInvalidLine(self, sequence=None, sequence_list=None, **kwd): # check we have two delivery cells: (one for year 1992 and one for 2003)
""" self.assertEqual(len(self.valid_outgoing_line.objectValues()), 2)
Delete the invalid cash classification line previously create for variation in self.variation_list:
""" # get the delivery cell
self.cash_classification.deleteContent('invalid_line') 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())
def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd): def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the total after the creation of the two cash classification lines Check the total after the creation of the two cash sorting lines
""" """
# Check number of lines (line1 + line2) # Check number of lines (line1 + line2)
self.assertEqual(len(self.cash_classification.objectValues()), 2) self.assertEqual(len(self.cash_sorting.objectValues()), 6)
# Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003 # Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
self.assertEqual(self.cash_classification.getTotalQuantity(), 5.0 + 12.0) self.assertEqual(self.cash_sorting.getTotalQuantity(), (5.0 + 12.0 + 24.0) * 2.0)
# check the total price # check the total price
self.assertEqual(self.cash_classification.getTotalPrice(), 10000 * 5.0 + 200 * 12.0) self.assertEqual(self.cash_sorting.getTotalPrice(), (10000 * 5.0 + 200 * 12.0 + 5000 * 24.0) * 2.0)
def stepConfirmCashClassification(self, sequence=None, sequence_list=None, **kwd): def stepOrderCashSorting(self, sequence=None, sequence_list=None, **kwd):
""" """
Confirm the cash classification and check it Order the cash sorting and check it
""" """
# fix amount (10000 * 5.0 + 200 * 12.0) # fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24)
self.cash_classification.setSourceTotalAssetPrice('52400.0') self.cash_sorting.setSourceTotalAssetPrice('172400.0')
# do the Workflow action # do the Workflow action
self.workflow_tool.doActionFor(self.cash_classification, 'confirm_action', wf_id='cash_classification_workflow') self.workflow_tool.doActionFor(self.cash_sorting, 'order_action', wf_id='cash_sorting_workflow')
# execute tic # execute tic
self.stepTic() self.stepTic()
# get state # get state
state = self.cash_classification.getSimulationState() state = self.cash_sorting.getSimulationState()
# check state is confirmed # check state is confirmed
self.assertEqual(state, 'confirmed') self.assertEqual(state, 'ordered')
# get workflow history # get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_classification, name='history', wf_id='cash_classification_workflow') workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of workflow history is 4 # check len of workflow history is 4
self.assertEqual(len(workflow_history), 4) self.assertEqual(len(workflow_history), 3)
def stepConfirmCashSorting(self, sequence=None, sequence_list=None, **kwd):
"""
Confirm the cash sorting and check it
"""
# 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')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of workflow history is 6
self.assertEqual(len(workflow_history), 5)
def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd): def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd):
""" """
Check that compution of inventory at vault caisse_lille is right after confirm and before deliver Check that compution of inventory at vault encaisse_paris is right after confirm and before deliver
""" """
# check we have 5 banknotes of 10000 currently # check we have 5 banknotes of 10000 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we will have 0 banknote of 10000 after deliver # check we will have 0 banknote of 10000 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_lille.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)
# check we have 12 coins of 200 currently # check we have 12 coins of 200 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check we will have 0 coin of 200 after deliver # check we will have 0 coin of 200 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.caisse_lille.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)
# 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)
def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd): def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd):
...@@ -381,58 +560,67 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -381,58 +560,67 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
Check that compution of inventory at vault encaisse_externe is right after confirm and before deliver Check that compution of inventory at vault encaisse_externe is right after confirm and before deliver
""" """
# check we have 0 banknote of 10000 currently # check we have 0 banknote of 10000 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_billets_et_monnaies.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
# check we will have 5 banknotes of 10000 after deliver # check we will have 5 banknotes of 10000 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_billets_et_monnaies.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we have 0 coin of 200 currently # check we have 0 coin of 200 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
# check we will have 12 coins of 200 after deliver # check we will have 12 coins of 200 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check for banknote of 5000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
# check we will have 12 coins of 200 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
def stepDeliverCashClassification(self, sequence=None, sequence_list=None, **kwd): def stepDeliverCashSorting(self, sequence=None, sequence_list=None, **kwd):
""" """
Deliver the cash classification with a good user Deliver the cash sorting with a good user
and check that the deliver of a cash tranfer have achieved and check that the deliver of a cash tranfer have achieved
""" """
# self.security_manager = AccessControl.getSecurityManager() # self.security_manager = AccessControl.getSecurityManager()
# self.user = self.security_manager.getUser() # self.user = self.security_manager.getUser()
# do the workflow transition "deliver_action" # do the workflow transition "deliver_action"
self.workflow_tool.doActionFor(self.cash_classification, 'deliver_action', wf_id='cash_classification_workflow') self.workflow_tool.doActionFor(self.cash_sorting, 'deliver_action', wf_id='cash_sorting_workflow')
# execute tic # execute tic
self.stepTic() self.stepTic()
# get state of cash classification # get state of cash sorting
state = self.cash_classification.getSimulationState() state = self.cash_sorting.getSimulationState()
# check that state is delivered # check that state is delivered
self.assertEqual(state, 'delivered') self.assertEqual(state, 'delivered')
# get workflow history # get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_classification, name='history', wf_id='cash_classification_workflow') workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of len workflow history is 6 # check len of len workflow history is 6
self.assertEqual(len(workflow_history), 6) self.assertEqual(len(workflow_history), 7)
def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd): def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd):
""" """
Check inventory at source (vault caisse_lille) after deliver of the cash classification Check inventory at source (vault encaisse_paris) after deliver of the cash sorting
""" """
# check we have 0 banknote of 10000 # check we have 0 banknote of 10000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0) 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.caisse_lille.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)
# check we have 0 coin of 200 # check we have 0 coin of 200
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.caisse_lille.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0) 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.caisse_lille.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)
def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd): def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd):
""" """
Check inventory at destination (vault encaisse_externe) after deliver of the cash classification Check inventory at destination (vault encaisse_externe) after deliver of the cash sorting
""" """
# check we have 5 banknotes of 10000 # check we have 5 banknotes of 10000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_billets_et_monnaies.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_billets_et_monnaies.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we have 12 coins of 200 # check we have 12 coins of 200
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check we have 24 banknotes of 5000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
################################## ##################################
...@@ -447,17 +635,16 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase): ...@@ -447,17 +635,16 @@ class TestERP5BankingCashClassification(TestERP5BankingMixin, ERP5TypeTestCase):
sequence_list = SequenceList() sequence_list = SequenceList()
# define the sequence # define the sequence
sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \ sequence_string = 'Tic CheckObjects Tic CheckInitialInventory CheckSource CheckDestination ' \
+ 'CreateCashClassification ' \ + 'CreateCashSorting ' \
+ 'CreateValidIncomingLine CheckSubTotal ' \ + 'CreateThreeValidIncomingLine CheckSubTotal ' \
+ 'CreateValidOutgoingLine CheckTotal ' \ + 'CreateValidOutgoingLineForInternalBanknote ' \
+ 'CreateValidOutgoingLineForExternalBanknote ' \
+ 'CreateValidOutgoingLineForInternalAndCancelledBanknote Tic CheckTotal ' \
+ 'CheckSource CheckDestination ' \ + 'CheckSource CheckDestination ' \
+ 'CreateInvalidLine ' \ + 'OrderCashSorting Tic '\
+ 'TryConfirmCashClassificationWithBadInventory ' \ + 'ConfirmCashSorting Tic ' \
+ 'DelInvalidLine Tic CheckTotal ' \
+ 'ConfirmCashClassification ' \
+ 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \
+ 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \ + 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \
+ 'DeliverCashClassification ' \ + 'DeliverCashSorting Tic ' \
+ 'CheckSourceDebit CheckDestinationCredit ' + 'CheckSourceDebit CheckDestinationCredit '
sequence_list.addSequenceString(sequence_string) sequence_list.addSequenceString(sequence_string)
# play the sequence # play the sequence
......
product/ERP5Banking/tests/testERP5BankingCashSorting.py 0 → 100755
View file @ c4cd2aea
##############################################################################
#
# 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
from Products.ERP5Banking.tests.TestERP5BankingMixin import TestERP5BankingMixin
# 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'))
class TestERP5BankingCashSorting(TestERP5BankingMixin, ERP5TypeTestCase):
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 "ERP5BankingCashSorting"
def getBusinessTemplateList(self):
"""
Return the list of business templates we need to run the test.
This method is called during the initialization of the unit test by
the unit test framework in order to know which business templates
need to be installed to run the test on.
"""
return ( 'erp5_base'
, 'erp5_banking_core' # erp5_banking_core contains all generic methods for banking
, 'erp5_banking_inventory'
, 'erp5_banking_cash' # erp5_banking_cash contains all method for cash sorting
)
def getCashSortingModule(self):
"""
Return the Cash Sorting Module
"""
return getattr(self.getPortal(), 'cash_sorting_module', None)
def afterSetUp(self):
"""
Method called before the launch of the test to initialize some data
"""
self.initDefaultVariable()
# Set some variables :
self.cash_sorting_module = self.getCashSortingModule()
# Create a user and login as manager to populate the erp5 portal with objects for tests.
self.createManagerAndLogin()
self.createFunctionGroupSiteCategory()
self.createBanknotesAndCoins()
inventory_dict_line_1 = {'id' : 'inventory_line_1',
'resource': self.billet_10000,
'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
'quantity': self.quantity_10000}
inventory_dict_line_2 = {'id' : 'inventory_line_2',
'resource': self.billet_200,
'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/not_defined', 'cash_status/to_sort') + self.variation_list,
'quantity': self.quantity_200}
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}
line_list = [inventory_dict_line_1, inventory_dict_line_2, inventory_dict_line_3]
self.encaisse_tri = self.paris.surface.salle_de_tri.encaisse_des_billets_et_monnaies
self.encaisse_reserve = self.paris.caveau.reserve.encaisse_des_billets_et_monnaies
self.encaisse_externe = self.paris.caveau.externes.encaisse_des_externes
self.encaisse_auxiliaire = self.paris.caveau.auxiliaire.encaisse_des_billets_et_monnaies
self.createCashInventory(source=None, destination=self.encaisse_tri, currency=self.currency_1,
line_list=line_list)
# 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')
def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd):
"""
Check that all the objects we created in afterSetUp or
that were added by the business template and that we rely
on are really here.
"""
self.checkResourceCreated()
# check that 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)
def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd):
"""
Check the initial inventory before any operations
"""
self.simulation_tool = self.getSimulationTool()
# 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)
# 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)
def stepCheckSource(self, sequence=None, sequence_list=None, **kwd):
"""
Check inventory in source vault (encaisse_paris) before a confirm
"""
# check we have 5 banknotes of 10000
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)
# check we have 12 coin of 200
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)
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
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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
# check we don't have coins of 200
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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
# 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)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
def stepCreateCashSorting(self, sequence=None, sequence_list=None, **kwd):
"""
Create a cash sorting document and check it
"""
# Cash sorting has encaisse_paris for source, encaisse_externe for destination, and a price cooreponding to the sum of banknote of 10000 and banknotes of 200 ( (2+3) * 1000 + (5+7) * 200 )
self.cash_sorting = self.cash_sorting_module.newContent(id='cash_sorting_1', portal_type='Cash Sorting', source_value=self.encaisse_tri, destination_value=None, source_total_asset_price=52400.0)
# execute tic
self.stepTic()
# 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')
# check its portal type
self.assertEqual(self.cash_sorting.getPortalType(), 'Cash Sorting')
# check that its source is encaisse_paris
self.assertEqual(self.cash_sorting.getSource(), 'site/testsite/paris/surface/salle_de_tri/encaisse_des_billets_et_monnaies')
# check that its destination is encaisse_externe
self.assertEqual(self.cash_sorting.getDestination(), None)
def stepCreateThreeValidIncomingLine(self, sequence=None, sequence_list=None, **kwd):
"""
Create the cash sorting incoming line with banknotes of 10000 and check it has been well created
"""
# 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,
self.quantity_10000)
# execute tic
self.stepTic()
# check there is only one line created
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')
# 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_10000)
# chek the value of the banknote
self.assertEqual(self.valid_incoming_line.getPrice(), 10000.0)
# check the unit of banknote
self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'quantity_unit/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_10000)
# check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_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(), 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())
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
self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'quantity_unit/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_200)
# check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_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(), 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
self.assertEqual(self.valid_incoming_line.getQuantityUnit(), 'quantity_unit/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_5000)
# check the source vault is encaisse_paris
self.assertEqual(cell.getSourceValue(), self.encaisse_tri)
# check the destination vault is encaisse_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(), 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())
def stepCheckSubTotal(self, sequence=None, sequence_list=None, **kwd):
"""
Check the amount after the creation of cash sorting line 1
"""
# Check number of lines
self.assertEqual(len(self.cash_sorting.objectValues()), 3)
# Check quantity of banknotes (2 for 1992 and 3 for 2003)
self.assertEqual(self.cash_sorting.getTotalQuantity(deliveryLineType="Incoming Cash Sorting Line"), 41.0)
# Check the total price
self.assertEqual(self.cash_sorting.getTotalPrice(deliveryLineType="Incoming Cash Sorting Line"), 10000 * 5.0 + 200 * 12.0 + 5000 * 24.0)
def stepCreateValidOutgoingLineForInternalBanknote(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_1', 'Outgoing Cash Sorting Line', self.billet_10000,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list,
self.quantity_10000)
# execute tic
self.stepTic()
# check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting.objectValues()), 4)
# get the second cash sorting line
self.valid_outgoing_line = getattr(self.cash_sorting, 'valid_outgoing_line_1')
# 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_10000)
# check the value of coin
self.assertEqual(self.valid_outgoing_line.getPrice(), 10000.0)
# check the unit of coin
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/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
cell = self.valid_outgoing_line.getCell('emission_letter/p', 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(), 2.0)
elif cell.getId() == 'movement_0_1_0':
# check the quantity for coin for year 2003 is 7
self.assertEqual(cell.getQuantity(), 3.0)
else:
self.fail('Wrong cell created : %s' % cell.getId())
def stepCreateValidOutgoingLineForExternalBanknote(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_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)
# execute tic
self.stepTic()
# check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting.objectValues()), 5)
# 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
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/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
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())
def stepCreateValidOutgoingLineForInternalAndCancelledBanknote(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_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)
# execute tic
self.stepTic()
# check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting.objectValues()), 6)
# 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
self.assertEqual(self.valid_outgoing_line.getQuantityUnit(), 'quantity_unit/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
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())
def stepCheckTotal(self, sequence=None, sequence_list=None, **kwd):
"""
Check the total after the creation of the two cash sorting lines
"""
# Check number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting.objectValues()), 6)
# Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
self.assertEqual(self.cash_sorting.getTotalQuantity(), (5.0 + 12.0 + 24.0) * 2.0)
# check the total price
self.assertEqual(self.cash_sorting.getTotalPrice(), (10000 * 5.0 + 200 * 12.0 + 5000 * 24.0) * 2.0)
def stepOrderCashSorting(self, sequence=None, sequence_list=None, **kwd):
"""
Order the cash sorting and check it
"""
# fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24)
self.cash_sorting.setSourceTotalAssetPrice('172400.0')
# do the Workflow action
self.workflow_tool.doActionFor(self.cash_sorting, 'order_action', wf_id='cash_sorting_workflow')
# execute tic
self.stepTic()
# get state
state = self.cash_sorting.getSimulationState()
# check state is confirmed
self.assertEqual(state, 'ordered')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of workflow history is 4
self.assertEqual(len(workflow_history), 3)
def stepConfirmCashSorting(self, sequence=None, sequence_list=None, **kwd):
"""
Confirm the cash sorting and check it
"""
# 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')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of workflow history is 6
self.assertEqual(len(workflow_history), 5)
def stepCheckSourceDebitPlanned(self, sequence=None, sequence_list=None, **kwd):
"""
Check that compution of inventory at vault encaisse_paris is right after confirm and before deliver
"""
# check we have 5 banknotes of 10000 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.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.encaisse_tri.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
# check we have 12 coins of 200 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_tri.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check we will have 0 coin of 200 after deliver
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)
def stepCheckDestinationCreditPlanned(self, sequence=None, sequence_list=None, **kwd):
"""
Check that compution of inventory at vault encaisse_externe is right after confirm and before deliver
"""
# check we have 0 banknote of 10000 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.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.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we have 0 coin of 200 currently
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 0.0)
# check we will have 12 coins of 200 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check for banknote of 5000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 0.0)
# check we will have 12 coins of 200 after deliver
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
def stepDeliverCashSorting(self, sequence=None, sequence_list=None, **kwd):
"""
Deliver the cash sorting with a good user
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"
self.workflow_tool.doActionFor(self.cash_sorting, 'deliver_action', wf_id='cash_sorting_workflow')
# execute tic
self.stepTic()
# get state of cash sorting
state = self.cash_sorting.getSimulationState()
# check that state is delivered
self.assertEqual(state, 'delivered')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting, name='history', wf_id='cash_sorting_workflow')
# check len of len workflow history is 6
self.assertEqual(len(workflow_history), 7)
def stepCheckSourceDebit(self, sequence=None, sequence_list=None, **kwd):
"""
Check inventory at source (vault encaisse_paris) after deliver of the cash sorting
"""
# check we have 0 banknote of 10000
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)
# check we have 0 coin of 200
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)
def stepCheckDestinationCredit(self, sequence=None, sequence_list=None, **kwd):
"""
Check inventory at destination (vault encaisse_externe) after deliver of the cash sorting
"""
# check we have 5 banknotes of 10000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_reserve.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we have 12 coins of 200
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_externe.getRelativeUrl(), resource = self.billet_200.getRelativeUrl()), 12.0)
# check we have 24 banknotes of 5000
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.encaisse_auxiliaire.getRelativeUrl(), resource = self.billet_5000.getRelativeUrl()), 24.0)
##################################
## Tests
##################################
def test_01_ERP5BankingCashSorting(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 ' \
+ 'CreateCashSorting ' \
+ 'CreateThreeValidIncomingLine CheckSubTotal ' \
+ 'CreateValidOutgoingLineForInternalBanknote ' \
+ 'CreateValidOutgoingLineForExternalBanknote ' \
+ 'CreateValidOutgoingLineForInternalAndCancelledBanknote Tic CheckTotal ' \
+ 'CheckSource CheckDestination ' \
+ 'OrderCashSorting Tic '\
+ 'ConfirmCashSorting Tic ' \
+ 'CheckSourceDebitPlanned CheckDestinationCreditPlanned ' \
+ 'DeliverCashSorting Tic ' \
+ '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(TestERP5BankingCashSorting))
return suite
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7