Commit bc16c6ce authored by Aurel's avatar Aurel

rewrite test to follow last modifications


git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@15106 20353a03-c40f-0410-a6d1-a30d3c3de9de
parent b829912a
############################################################################## ##############################################################################
# #
# Copyright (c) 2005-2006 Nexedi SARL and Contributors. All Rights Reserved. # Copyright (c) 2005-2007 Nexedi SARL and Contributors. All Rights Reserved.
# Aurelien Calonne <aurel@nexedi.com> # Aurelien Calonne <aurel@nexedi.com>
# #
# WARNING: This program as such is intended to be used by professional # WARNING: This program as such is intended to be used by professional
...@@ -47,40 +47,11 @@ if __name__ == '__main__': ...@@ -47,40 +47,11 @@ if __name__ == '__main__':
class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase): class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase):
""" """
This class is a unit test to check the module of Cash Sorting Incident This class is a unit test to check the module of Incident
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
- check it has been created correctly
- check source and destination (current == future)
- create a "Note Line" (billetage)
- check it has been created correctly
- check the total amount
- create a second Line
- check it has been created correctly
- check the total amount
- create an invalid Line (quantity > available at source)
- check that the system behaves correctly
- pass "confirm_action" transition
- check that the new state is confirmed
- check that the source has been debited correctly (current < future)
- check amount, lines, ...
- pass "deliver_action" transition
- check that the new state is delivered
- check that the destination has been credited correctly (current == future)
""" """
login = PortalTestCase.login login = PortalTestCase.login
# pseudo constants
RUN_ALL_TEST = 1 # we want to run all test RUN_ALL_TEST = 1 # we want to run all test
QUIET = 0 # we don't want the test to be quiet QUIET = 0 # we don't want the test to be quiet
...@@ -94,48 +65,22 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -94,48 +65,22 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
""" """
Return the Cash Transer Module Return the Cash Transer Module
""" """
return getattr(self.getPortal(), 'cash_sorting_incident_module', None) return getattr(self.getPortal(), 'incident_module', None)
def afterSetUp(self): def afterSetUp(self):
""" """
Method called before the launch of the test to initialize some data Method called before the launch of the test to initialize some data
""" """
# Set some variables :
self.initDefaultVariable() self.initDefaultVariable()
# the cahs transfer module
self.cash_sorting_incident_module = self.getCashSortingIncidentModule() self.cash_sorting_incident_module = self.getCashSortingIncidentModule()
self.createManagerAndLogin() self.createManagerAndLogin()
self.createFunctionGroupSiteCategory(site_list=['paris'])
# create categories
self.createFunctionGroupSiteCategory()
# create resources # create resources
self.createBanknotesAndCoins() self.createBanknotesAndCoins()
self.vault = self.paris.surface.banque_interne
# Before the test, we need to input the inventory self.incoming_vault = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.entrante
self.outgoing_vault = self.paris.surface.banque_interne.guichet_1.encaisse_des_billets_et_monnaies.sortante
inventory_dict_line_1 = {'id' : 'inventory_line_1',
'resource': self.billet_10000,
'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list,
'quantity': self.quantity_10000}
inventory_dict_line_2 = {'id' : 'inventory_line_2',
'resource': self.piece_200,
'variation_id': ('emission_letter', 'cash_status', 'variation'),
'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list,
'quantity': self.quantity_200}
self.line_list = line_list = [inventory_dict_line_1, inventory_dict_line_2]
self.diff_vault = self.paris.surface.caisse_courante.encaisse_des_billets_et_monnaies
self.createCashInventory(source=None, destination=self.diff_vault, 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.checkUserFolderType()
self.organisation = self.organisation_module.newContent(id='baobab_org', portal_type='Organisation', self.organisation = self.organisation_module.newContent(id='baobab_org', portal_type='Organisation',
function='banking', group='baobab', site='testsite/paris') function='banking', group='baobab', site='testsite/paris')
...@@ -143,12 +88,12 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -143,12 +88,12 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
user_dict = { user_dict = {
'super_user' : [['Manager'], self.organisation, 'banking/comptable', 'baobab', 'testsite/paris/surface/banque_interne/guichet_1'] 'super_user' : [['Manager'], self.organisation, 'banking/comptable', 'baobab', 'testsite/paris/surface/banque_interne/guichet_1']
} }
# call method to create this user
self.createERP5Users(user_dict) self.createERP5Users(user_dict)
self.logout() self.logout()
self.login('super_user') self.login('super_user')
# open counter date # open counter date
self.openCounterDate(site=self.paris) self.openCounterDate(site=self.paris)
self.openCounter(site=self.vault)
def stepDeleteCashSortingIncident(self, sequence=None, sequence_list=None, **kwd): def stepDeleteCashSortingIncident(self, sequence=None, sequence_list=None, **kwd):
""" """
...@@ -156,6 +101,18 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -156,6 +101,18 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
""" """
self.cash_sorting_incident_module.manage_delObjects(['cash_sorting_incident_1',]) self.cash_sorting_incident_module.manage_delObjects(['cash_sorting_incident_1',])
def stepDelOutgoingLine(self, sequence=None, sequence_list=None, **kwd):
"""
Delete the invalid cash transfer line previously create
"""
self.cash_sorting_incident.deleteContent('valid_line_2')
def stepDelIncomingLine(self, sequence=None, sequence_list=None, **kwd):
"""
Delete the invalid cash transfer line previously create
"""
self.cash_sorting_incident.deleteContent('valid_line_1')
def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd): def stepCheckObjects(self, sequence=None, sequence_list=None, **kwd):
""" """
Check that all the objects we created in afterSetUp or Check that all the objects we created in afterSetUp or
...@@ -163,94 +120,71 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -163,94 +120,71 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
on are really here. on are really here.
""" """
self.checkResourceCreated() self.checkResourceCreated()
# check that CashSortingIncident Module was created self.assertEqual(self.cash_sorting_incident_module.getPortalType(), 'Incident Module')
self.assertEqual(self.cash_sorting_incident_module.getPortalType(), 'Cash Sorting Incident Module')
# check cash transfer module is empty
self.assertEqual(len(self.cash_sorting_incident_module.objectValues()), 0) self.assertEqual(len(self.cash_sorting_incident_module.objectValues()), 0)
def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd): def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kwd):
""" """
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 usual_cash self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
# check we have 12 coin of 200 in usual_cash self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
def stepCreateCashSortingIncident(self, sequence=None, sequence_list=None, **kwd): def stepCreateCashSortingIncident(self, sequence=None, sequence_list=None, **kwd):
""" """
Create a cash transfer document and check it Create a cash transfer document and check it
""" """
# Cash transfer has usual_cash for source, counter for destination, and a price cooreponding to the sum of banknote of 10000 abd coin of 200 ( (2+3) * 1000 + (5+7) * 200 )
self.cash_sorting_incident = self.cash_sorting_incident_module.newContent( self.cash_sorting_incident = self.cash_sorting_incident_module.newContent(
id='cash_sorting_incident_1', id='cash_sorting_incident_1',
portal_type='Cash Sorting Incident', portal_type='Incident',
description='test', description='test',
incident_type = "cash_sorting_incident",
resource_value=self.currency_1,
source_total_asset_price=52400.0,) source_total_asset_price=52400.0,)
# execute tic
self.stepTic() self.stepTic()
# check we have only one cash transfer # Check it
self.assertEqual(len(self.cash_sorting_incident_module.objectValues()), 1) self.assertEqual(len(self.cash_sorting_incident_module.objectValues()), 1)
# set source reference
self.setDocumentSourceReference(self.cash_sorting_incident) self.setDocumentSourceReference(self.cash_sorting_incident)
# check source reference
self.assertNotEqual(self.cash_sorting_incident.getSourceReference(), '') self.assertNotEqual(self.cash_sorting_incident.getSourceReference(), '')
self.assertNotEqual(self.cash_sorting_incident.getSourceReference(), None) self.assertNotEqual(self.cash_sorting_incident.getSourceReference(), None)
# get the cash transfer document
self.cash_sorting_incident = getattr(self.cash_sorting_incident_module, 'cash_sorting_incident_1') self.cash_sorting_incident = getattr(self.cash_sorting_incident_module, 'cash_sorting_incident_1')
# check its portal type self.assertEqual(self.cash_sorting_incident.getPortalType(), 'Incident')
self.assertEqual(self.cash_sorting_incident.getPortalType(), 'Cash Sorting Incident') self.assertEqual(self.cash_sorting_incident.getSource(), None)
# check that its destination is counter
self.assertEqual(self.cash_sorting_incident.getSource(), 'site/testsite/paris')
self.assertEqual(self.cash_sorting_incident.getDestination(), None) self.assertEqual(self.cash_sorting_incident.getDestination(), None)
def stepCreateIncomingLine(self, sequence=None, sequence_list=None, **kwd): def stepCreateIncomingLine(self, sequence=None, sequence_list=None, **kwd):
""" """
Create the cash transfer line 1 with banknotes of 10000 and check it has been well created Create the cash transfer line 1 with banknotes of 10000 and check it has been well created
""" """
# create the cash transfer line self.addCashLineToDelivery(self.cash_sorting_incident, 'valid_line_1', 'Incoming Incident Line', self.billet_10000,
self.addCashLineToDelivery(self.cash_sorting_incident, 'valid_line_1', 'Incoming Cash Sorting Incident Line', self.billet_10000,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list,
self.quantity_10000) self.quantity_10000)
# execute tic
self.stepTic() self.stepTic()
# check there is only one line created
self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1) self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1)
# get the cash transfer line
self.valid_line_1 = getattr(self.cash_sorting_incident, 'valid_line_1') self.valid_line_1 = getattr(self.cash_sorting_incident, 'valid_line_1')
# check its portal type self.assertEqual(self.valid_line_1.getPortalType(), 'Incoming Incident Line')
self.assertEqual(self.valid_line_1.getPortalType(), 'Incoming Cash Sorting Incident Line')
# check the resource is banknotes of 10000
self.assertEqual(self.valid_line_1.getResourceValue(), self.billet_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) self.assertEqual(self.valid_line_1.getPrice(), 10000.0)
# check the unit of banknote
self.assertEqual(self.valid_line_1.getQuantityUnit(), 'unit') self.assertEqual(self.valid_line_1.getQuantityUnit(), 'unit')
# check we have two delivery cells: (one for year 1992 and one for 2003)
self.assertEqual(len(self.valid_line_1.objectValues()), 2) self.assertEqual(len(self.valid_line_1.objectValues()), 2)
# 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
cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid') cell = self.valid_line_1.getCell('emission_letter/p', variation, 'cash_status/valid')
# chek portal types
self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
# check the source vault is usual_cash
self.assertEqual(cell.getBaobabSourceValue(), None) self.assertEqual(cell.getBaobabSourceValue(), None)
# check the destination vault is counter self.assertEqual(cell.getBaobabDestination(), None)
self.assertEqual(cell.getBaobabDestination(), self.diff_vault.getRelativeUrl())
# check the banknote of the cell is banknote of 10000
self.assertEqual(cell.getResourceValue(), self.billet_10000) self.assertEqual(cell.getResourceValue(), self.billet_10000)
if cell.getId() == 'movement_0_0_0': if cell.getId() == 'movement_0_0_0':
# check the quantity of banknote for year 1992 is 2
self.assertEqual(cell.getQuantity(), 2.0) self.assertEqual(cell.getQuantity(), 2.0)
elif cell.getId() == 'movement_0_1_0': elif cell.getId() == 'movement_0_1_0':
# check the quantity of banknote for year 2003 is 3
self.assertEqual(cell.getQuantity(), 3.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())
...@@ -260,11 +194,8 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -260,11 +194,8 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
""" """
Check the amount after the creation of cash transfer line 1 Check the amount after the creation of cash transfer line 1
""" """
# Check number of lines
self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1) self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1)
# Check quantity of banknotes (2 for 1992 and 3 for 2003)
self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 5.0) self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 5.0)
# Check the total price
self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 10000 * 5.0) self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 10000 * 5.0)
...@@ -272,117 +203,66 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -272,117 +203,66 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
""" """
Create the cash transfer line 2 wiht coins of 200 and check it has been well created Create the cash transfer line 2 wiht coins of 200 and check it has been well created
""" """
# create the line self.addCashLineToDelivery(self.cash_sorting_incident, 'valid_line_2', 'Outgoing Incident Line', self.piece_200,
self.addCashLineToDelivery(self.cash_sorting_incident, 'valid_line_2', 'Outgoing Cash Sorting Incident Line', self.piece_200,
('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list, ('emission_letter', 'cash_status', 'variation'), ('emission_letter/p', 'cash_status/valid') + self.variation_list,
self.quantity_200) self.quantity_200)
# execute tic
self.stepTic() self.stepTic()
# check the number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting_incident.objectValues()), 2) self.assertEqual(len(self.cash_sorting_incident.objectValues()), 2)
# get the second cash transfer line
self.valid_line_2 = getattr(self.cash_sorting_incident, 'valid_line_2') self.valid_line_2 = getattr(self.cash_sorting_incident, 'valid_line_2')
# check portal types self.assertEqual(self.valid_line_2.getPortalType(), 'Outgoing Incident Line')
self.assertEqual(self.valid_line_2.getPortalType(), 'Outgoing Cash Sorting Incident Line')
# check the resource is coin of 200
self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200) self.assertEqual(self.valid_line_2.getResourceValue(), self.piece_200)
# check the value of coin
self.assertEqual(self.valid_line_2.getPrice(), 200.0) self.assertEqual(self.valid_line_2.getPrice(), 200.0)
# check the unit of coin
self.assertEqual(self.valid_line_2.getQuantityUnit(), 'unit') self.assertEqual(self.valid_line_2.getQuantityUnit(), 'unit')
# check we have two delivery cells: (one for year 1992 and one for 2003)
self.assertEqual(len(self.valid_line_2.objectValues()), 2) self.assertEqual(len(self.valid_line_2.objectValues()), 2)
for variation in self.variation_list: for variation in self.variation_list:
# get the delivery cell
cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid') cell = self.valid_line_2.getCell('emission_letter/p', variation, 'cash_status/valid')
# check the portal type
self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell') self.assertEqual(cell.getPortalType(), 'Cash Delivery Cell')
# check the source vault is usual_cash self.assertEqual(cell.getBaobabSource(), None)
self.assertEqual(cell.getBaobabSource(), self.diff_vault.getRelativeUrl())
# check the destination vault is counter
self.assertEqual(cell.getBaobabDestinationValue(), None) self.assertEqual(cell.getBaobabDestinationValue(), None)
if cell.getId() == 'movement_0_0_0': if cell.getId() == 'movement_0_0_0':
# check the quantity for coin for year 1992 is 5
self.assertEqual(cell.getQuantity(), 5.0) self.assertEqual(cell.getQuantity(), 5.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
self.assertEqual(cell.getQuantity(), 7.0) self.assertEqual(cell.getQuantity(), 7.0)
else: else:
self.fail('Wrong cell created : %s' % cell.getId()) self.fail('Wrong cell created : %s' % cell.getId())
def stepTryPlanCashSortingIncidentWithTwoDifferentLines(self, sequence=None, sequence_list=None, **kwd): def stepTryDeliverCashSortingIncidentWithTwoDifferentLines(self, sequence=None, sequence_list=None, **kwd):
""" """
""" """
# fix amount (10000 * 5.0 + 200 * 12.0 + 5000 * 24)
self.cash_sorting_incident.setSourceTotalAssetPrice('172400.0') self.cash_sorting_incident.setSourceTotalAssetPrice('172400.0')
# try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition self.assertWorkflowTransitionFails(object=self.cash_sorting_incident, transition_id='deliver_action',
self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.cash_sorting_incident, 'plan_action', wf_id='cash_sorting_incident_workflow') workflow_id='incident_workflow', error_message="You can't have excess and deficit on the same document.")
# execute tic
self.stepTic() self.stepTic()
# get state of the cash transfer self.assertEqual(self.cash_sorting_incident.getSimulationState(), 'ordered')
state = self.cash_sorting_incident.getSimulationState()
# check the state is draft
self.assertEqual(state, 'draft')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting_incident, name='history', wf_id='cash_sorting_incident_workflow')
# check we get an "Insufficient balance" message in the workflow history because of the invalid line
msg = workflow_history[-1]['error_message']
self.assertEqual("You can't have excess and deficit on the document.", "%s" %(msg,))
def stepDelOutgoingLine(self, sequence=None, sequence_list=None, **kwd):
"""
Delete the invalid cash transfer line previously create
"""
self.cash_sorting_incident.deleteContent('valid_line_2')
def stepDelIncomingLine(self, sequence=None, sequence_list=None, **kwd): def stepTryDeliverCashSortingIncidentWithBadPrice(self, sequence=None, sequence_list=None, **kwd):
"""
Delete the invalid cash transfer line previously create
"""
self.cash_sorting_incident.deleteContent('valid_line_1')
def stepTryPlanCashSortingIncidentWithBadPrice(self, sequence=None, sequence_list=None, **kwd):
""" """
Try to confirm the cash transfer with a bad cash transfer line and Try to confirm the cash transfer with a bad cash transfer line and
check the try of confirm the cash transfer with the invalid line has failed check the try of confirm the cash transfer with the invalid line has failed
""" """
# try to do the workflow action "confirm_action', cath the exception ValidationFailed raised by workflow transition self.assertWorkflowTransitionFails(object=self.cash_sorting_incident, transition_id='deliver_action',
self.assertRaises(ValidationFailed, self.workflow_tool.doActionFor, self.cash_sorting_incident, 'plan_action', wf_id='cash_sorting_incident_workflow') workflow_id='incident_workflow',
# execute tic error_message="Price differs between document and cash detail.")
self.stepTic() self.stepTic()
# get state of the cash transfer self.assertEqual(self.cash_sorting_incident.getSimulationState(), 'ordered')
state = self.cash_sorting_incident.getSimulationState()
# check the state is draft
self.assertEqual(state, 'draft')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting_incident, name='history', wf_id='cash_sorting_incident_workflow')
# check we get an "Insufficient balance" message in the workflow history because of the invalid line
msg = workflow_history[-1]['error_message']
self.assertEqual("Price differs between document and resource.", "%s" %(msg,))
def stepCheckTotalIncoming(self, sequence=None, sequence_list=None, **kwd): def stepCheckTotalIncoming(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the total after the creation of the two cash transfer lines Check the total after the creation of the two cash transfer lines
""" """
# Check number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1) self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1)
# Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 5.0) self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 5.0)
# check the total price
self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 10000 * 5.0) self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 10000 * 5.0)
def stepCheckTotalOutgoing(self, sequence=None, sequence_list=None, **kwd): def stepCheckTotalOutgoing(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the total after the creation of the two cash transfer lines Check the total after the creation of the two cash transfer lines
""" """
# Check number of lines (line1 + line2)
self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1) self.assertEqual(len(self.cash_sorting_incident.objectValues()), 1)
# Check quantity, banknotes : 2 for 1992 and 3 for 2003, coin : 5 for 1992 and 7 for 2003
self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 12.0) self.assertEqual(self.cash_sorting_incident.getTotalQuantity(), 12.0)
# check the total price
self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 200 * 12.0) self.assertEqual(self.cash_sorting_incident.getTotalPrice(), 200 * 12.0)
def stepSetIncomingTotalAssetPrice(self, sequence=None, sequence_list=None, **kwd): def stepSetIncomingTotalAssetPrice(self, sequence=None, sequence_list=None, **kwd):
...@@ -395,91 +275,112 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -395,91 +275,112 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
""" """
Confirm the cash transfer and check it Confirm the cash transfer and check it
""" """
# do the Workflow action self.workflow_tool.doActionFor(self.cash_sorting_incident, 'plan_action', wf_id='incident_workflow')
self.workflow_tool.doActionFor(self.cash_sorting_incident, 'plan_action', wf_id='cash_sorting_incident_workflow')
# execute tic
self.stepTic() self.stepTic()
# get state
state = self.cash_sorting_incident.getSimulationState() state = self.cash_sorting_incident.getSimulationState()
# check state is confirmed
self.assertEqual(state, 'planned') self.assertEqual(state, 'planned')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting_incident, name='history', wf_id='cash_sorting_incident_workflow')
def stepOrderCashSortingIncident(self, sequence=None, sequence_list=None, **kwd):
"""
Order the cash transfer and check it
"""
self.cash_sorting_incident.setSource(self.vault.getRelativeUrl())
self.workflow_tool.doActionFor(self.cash_sorting_incident, 'order_action', wf_id='incident_workflow')
self.assertEqual(self.cash_sorting_incident.getSimulationState(), 'ordered')
def stepConfirmCashSortingIncident(self, sequence=None, sequence_list=None, **kwd): def stepConfirmCashSortingIncident(self, sequence=None, sequence_list=None, **kwd):
""" """
Archive the cash transfer with a good user Archive the cash transfer with a good user
and check that the archive of a cash tranfer have achieved and check that the archive of a cash tranfer have achieved
""" """
# do the workflow transition "archive_action" self.workflow_tool.doActionFor(self.cash_sorting_incident, 'confirm_action', wf_id='incident_workflow')
self.workflow_tool.doActionFor(self.cash_sorting_incident, 'confirm_action', wf_id='cash_sorting_incident_workflow')
# execute tic
self.stepTic() self.stepTic()
# get state of cash transfer
state = self.cash_sorting_incident.getSimulationState() state = self.cash_sorting_incident.getSimulationState()
# check that state is archiveed
self.assertEqual(state, 'confirmed') self.assertEqual(state, 'confirmed')
# get workflow history
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting_incident, name='history', wf_id='cash_sorting_incident_workflow')
def stepDeliverCashSortingIncident(self, sequence=None, sequence_list=None, **kwd): def stepDeliverCashSortingIncident(self, sequence=None, sequence_list=None, **kwd):
""" """
Archive the cash transfer with a good user Archive the cash transfer with a good user
and check that the archive of a cash tranfer have achieved and check that the archive of a cash tranfer have achieved
""" """
# do the workflow transition "archive_action"
self.cash_sorting_incident.deliver() self.cash_sorting_incident.deliver()
# execute tic
self.stepTic() self.stepTic()
# get state of cash transfer
state = self.cash_sorting_incident.getSimulationState() state = self.cash_sorting_incident.getSimulationState()
# check that state is archiveed
self.assertEqual(state, 'delivered') self.assertEqual(state, 'delivered')
# get workflow history # Check we don't have more line than required
workflow_history = self.workflow_tool.getInfoFor(ob=self.cash_sorting_incident, name='history', wf_id='cash_sorting_incident_workflow') self.assertEqual(len(self.cash_sorting_incident.objectIds()), 1)
def stepCheckFinalIncomingInventory(self, sequence=None, sequence_list=None, **kwd): def stepCheckFinalIncomingInventory(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the final, nothing should have changed Check the final, nothing should have changed
""" """
self.simulation_tool = self.getSimulationTool() self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
# check we have 5 banknotes of 10000 in usual_cash self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 10.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 10.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
# check we have 12 coin of 200 in usual_cash self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 12.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
def stepCheckFinalOutgoingInventory(self, sequence=None, sequence_list=None, **kwd): def stepCheckFinalOutgoingInventory(self, sequence=None, sequence_list=None, **kwd):
""" """
Check the final, nothing should have changed Check the final, nothing should have changed
""" """
self.simulation_tool = self.getSimulationTool() self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
# check we have 5 banknotes of 10000 in usual_cash self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 5.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
# check we have 12 coin of 200 in usual_cash self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.diff_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0) self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(), resource = self.piece_200.getRelativeUrl()), 0.0)
def stepResetSourceInventory(self, def stepCreateOutgoingInventory(self, sequence=None, sequence_list=None, **kwd):
sequence=None, sequence_list=None, **kwd):
""" """
Reset a vault Create an inventory for outgoing lines
""" """
node = self.diff_vault inventory_dict_line = {'id' : 'inventory_line',
line_list = self.line_list 'resource': self.piece_200,
self.resetInventory(destination=node, currency=self.currency_1, 'variation_id': ('emission_letter', 'cash_status', 'variation'),
line_list=line_list,extra_id='_reset_out') 'variation_value': ('emission_letter/p', 'cash_status/valid') + self.variation_list,
'quantity': self.quantity_200}
self.createCashInventory(source=None, destination=self.outgoing_vault, currency=self.currency_1,
line_list=[inventory_dict_line,])
def stepCheckOutgoingInventory(self, sequence=None, sequence_list=None, **kwd):
"""
Check the initial inventory before any operations
"""
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(),
resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(),
resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.incoming_vault.getRelativeUrl(),
resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.incoming_vault.getRelativeUrl(),
resource = self.piece_200.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(),
resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(),
resource = self.billet_10000.getRelativeUrl()), 0.0)
self.assertEqual(self.simulation_tool.getCurrentInventory(node=self.outgoing_vault.getRelativeUrl(),
resource = self.piece_200.getRelativeUrl()), 12.0)
self.assertEqual(self.simulation_tool.getAvailableInventory(node=self.outgoing_vault.getRelativeUrl(),
resource = self.piece_200.getRelativeUrl()), 12.0)
self.assertEqual(self.simulation_tool.getFutureInventory(node=self.outgoing_vault.getRelativeUrl(),
resource = self.piece_200.getRelativeUrl()), 0.0)
def stepDeliverCashSortingIncidentFails(self, sequence=None, sequence_list=None, **kwd): def stepDeliverCashSortingIncidentFails(self, sequence=None, sequence_list=None, **kwd):
""" """
Try if we get Insufficient balance Try if we get Insufficient balance
""" """
message = self.assertWorkflowTransitionFails(self.cash_sorting_incident, message = self.assertWorkflowTransitionFails(self.cash_sorting_incident,
'cash_sorting_incident_workflow','deliver_action') 'incident_workflow','deliver_action')
self.failUnless(message.find('Insufficient balance')>=0) self.failUnless(message.find('Insufficient balance')>=0)
################################## ##################################
...@@ -493,38 +394,37 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase) ...@@ -493,38 +394,37 @@ class TestERP5BankingCashSortingIncident(TestERP5BankingMixin, ERP5TypeTestCase)
if not run: return if not run: return
sequence_list = SequenceList() sequence_list = SequenceList()
# define the sequence with incoming line # define the sequence with incoming line
sequence_string = 'Tic CheckObjects Tic CheckInitialInventory ' \ sequence_string_1 = 'Tic CheckObjects Tic CheckInitialInventory ' \
+ 'CreateCashSortingIncident ' \ + 'CreateCashSortingIncident ' \
+ 'PlanCashSortingIncident Tic ' \
+ 'OrderCashSortingIncident Tic ' \
+ 'CreateIncomingLine CheckSubTotal ' \ + 'CreateIncomingLine CheckSubTotal ' \
+ 'CreateOutgoingLine ' \ + 'CreateOutgoingLine ' \
+ 'TryPlanCashSortingIncidentWithTwoDifferentLines DelOutgoingLine Tic ' \ + 'TryDeliverCashSortingIncidentWithTwoDifferentLines DelOutgoingLine Tic ' \
+ 'TryPlanCashSortingIncidentWithBadPrice ' \ + 'TryDeliverCashSortingIncidentWithBadPrice ' \
+ 'Tic CheckTotalIncoming ' \ + 'Tic CheckTotalIncoming ' \
+ 'SetIncomingTotalAssetPrice ' \ + 'SetIncomingTotalAssetPrice ' \
+ 'PlanCashSortingIncident ' \
+ 'ConfirmCashSortingIncident ' \
+ 'DeliverCashSortingIncident ' \ + 'DeliverCashSortingIncident ' \
+ 'Tic ' \ + 'Tic ' \
+ 'CheckFinalIncomingInventory ' + 'CheckFinalIncomingInventory '
sequence_list.addSequenceString(sequence_string) sequence_list.addSequenceString(sequence_string_1)
# define the sequence with outgoing line # define the sequence with outgoing line
sequence_string = 'Tic DeleteCashSortingIncident Tic CheckInitialInventory ' \ sequence_string_2 = 'Tic DeleteCashSortingIncident Tic CheckInitialInventory ' \
+ 'CreateCashSortingIncident ' \ + 'CreateCashSortingIncident ' \
+ 'PlanCashSortingIncident Tic ' \
+ 'OrderCashSortingIncident Tic ' \
+ 'CreateIncomingLine CheckSubTotal ' \ + 'CreateIncomingLine CheckSubTotal ' \
+ 'CreateOutgoingLine ' \ + 'CreateOutgoingLine ' \
+ 'TryPlanCashSortingIncidentWithTwoDifferentLines DelIncomingLine Tic ' \ + 'TryDeliverCashSortingIncidentWithTwoDifferentLines DelIncomingLine Tic ' \
+ 'TryPlanCashSortingIncidentWithBadPrice ' \ + 'TryDeliverCashSortingIncidentWithBadPrice ' \
+ 'Tic CheckTotalOutgoing ' \ + 'Tic CheckTotalOutgoing ' \
+ 'SetOutgoingTotalAssetPrice ' \ + 'SetOutgoingTotalAssetPrice ' \
+ 'PlanCashSortingIncident ' \
+ 'ConfirmCashSortingIncident ' \
+ 'ResetSourceInventory Tic ' \
+ 'DeliverCashSortingIncidentFails Tic ' \ + 'DeliverCashSortingIncidentFails Tic ' \
+ 'DeleteResetInventory Tic ' \ + 'CreateOutgoingInventory Tic CheckOutgoingInventory ' \
+ 'DeliverCashSortingIncident ' \ + 'DeliverCashSortingIncident ' \
+ 'Tic ' \ + 'Tic ' \
+ 'CheckFinalOutgoingInventory ' + 'CheckFinalOutgoingInventory '
sequence_list.addSequenceString(sequence_string) sequence_list.addSequenceString(sequence_string_2)
# play the sequence # play the sequence
sequence_list.play(self) sequence_list.play(self)
......
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