Skip to content

erp5
erp5
Commit db416ddd authored by Jérome Perrin's avatar Jérome Perrin
Browse files
Options

add tests for : 

 * invoice with cells
 * updateAppliedRule when adding/editing/removing/adding cells to an invoice line


git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@3841 20353a03-c40f-0410-a6d1-a30d3c3de9de
parent 69e9802a
Hide whitespace changes
Inline Side-by-side
Showing with 534 additions and 45 deletions
product/ERP5/tests/testAccountingRules.py
View file @ db416ddd
......@@ -2,7 +2,7 @@
#
# Copyright (c) 2004 Nexedi SARL and Contributors. All Rights Reserved.
# Sebastien Robin <seb@nexedi.com>
# Jrome Perrin <jerome@nexedi.com>
# Jerome Perrin <jerome@nexedi.com>
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
......@@ -32,16 +32,13 @@ This tests also do basic checks for XMLMatrix and Predicate matching the
way it is used in the invoice related simulation.
"""
#
# TODO :
# * test match fr different predicate
# * test invoice with cells
# * test updateAppliedRule when modifying cell / lines
# * test with a Person as destination_section
# * test payment rule & payment builder
# * test invoicing rule by connecting to order test.
#
import os, sys
import os, sys, random
if __name__ == '__main__':
execfile(os.path.join(sys.path[0], 'framework.py'))
......@@ -59,20 +56,13 @@ from DateTime import DateTime
class TestAccountingRules(ERP5TypeTestCase):
"""
This should test these functions :
- in InvoiceRule.py :
- expand
- in InvoiceTransactionRule.py and PaymentRule.py :
- test
- expand
- newCellContent
- updateMatrix
- getCellByPredicate
This should test the simulation tree and builds starting from the
invoice.
"""
RUN_ALL_TESTS = 1
RUN_BROKEN_TESTS = os.getenv('RUN_BROKEN_TESTS', 0)
# define portal_types
account_module_portal_type = "Account Module"
......@@ -90,7 +80,8 @@ class TestAccountingRules(ERP5TypeTestCase):
sale_invoice_transaction_portal_type = "Sale Invoice Transaction"
sale_invoice_transaction_line_portal_type \
= "Sale Invoice Transaction Line"
sale_invoice_line_portal_type = "Sale Invoice Line"
sale_invoice_line_portal_type = "Invoice Line"
sale_invoice_cell_portal_type = "Invoice Cell"
purchase_invoice_transaction_portal_type \
= "Purchase Invoice Transaction"
......@@ -215,6 +206,9 @@ class TestAccountingRules(ERP5TypeTestCase):
def stepTic(self, **kw):
self.tic()
def stepCommitTransaction(self, **kw):
get_transaction().commit()
def stepCreateSaleInvoiceTransactionRule(self, sequence, **kw) :
"""
Create some predicates in the Invoice Transaction Rule
......@@ -518,6 +512,27 @@ class TestAccountingRules(ERP5TypeTestCase):
# XXX: for now there are no cells in payment rule, so nothing to do here
# TODO
def stepCreateEmptyInvoice(self, sequence, **kw) :
""" Create an empty invoice that will be modified later """
vendor = sequence.get('vendor')
client = sequence.get('client')
currency = sequence.get('currency')
empty_invoice = self.getAccountingModule().newContent(
id = 'empty_invoice',
portal_type = self.sale_invoice_transaction_portal_type,
resource = currency.getRelativeUrl(),
stop_date = DateTime(2004, 01, 01),
start_date = DateTime(2004, 01, 01),
source_section = vendor.getRelativeUrl(),
destination_section = client.getRelativeUrl(),
)
sequence.edit(
simple_invoice = empty_invoice,
invoice = empty_invoice,
)
def stepCreateSimpleSaleInvoice(self, sequence, **kw) :
""" creates a simple sale invoice for non varianted notebook product.
The invoice is from `vendor` to `client_fr`, so the cell defined in
......@@ -544,7 +559,8 @@ class TestAccountingRules(ERP5TypeTestCase):
id = 'invoice_line',
resource = product_notebook.getRelativeUrl(),
quantity = 10,
price = 10)
price = 10,
portal_type = self.sale_invoice_line_portal_type)
self.assertEqual(invoice_line.getTotalPrice(), 100)
......@@ -555,6 +571,87 @@ class TestAccountingRules(ERP5TypeTestCase):
invoice_lines = [invoice_line]
)
def stepCreateOtherSimpleSaleInvoice(self, sequence, **kw) :
""" creates a simple sale invoice for non varianted notebook product.
It will contain one line that will later be changed.
"""
vendor = sequence.get('vendor')
client = sequence.get('client')
product_notebook = sequence.get('product_notebook')
currency = sequence.get('currency')
simple_invoice = self.getAccountingModule().newContent(
id = 'other_simple_invoice',
portal_type = self.sale_invoice_transaction_portal_type,
resource = currency.getRelativeUrl(),
stop_date = DateTime(2004, 01, 01),
start_date = DateTime(2004, 01, 01),
source_section = vendor.getRelativeUrl(),
destination_section = client.getRelativeUrl(),
)
invoice_line = simple_invoice.newContent(
id = 'invoice_line',
resource = product_notebook.getRelativeUrl(),
quantity = 123,
price = 456,
portal_type = self.sale_invoice_line_portal_type)
sequence.edit(
simple_invoice = simple_invoice,
invoice = simple_invoice,
invoice_line = invoice_line,
invoice_lines = [invoice_line]
)
def stepAddInvoiceLine(self, sequence, **kw) :
""" add an invoice line in the current invoice :
10 notebook * 10 EUR, so total price is 100
"""
product_notebook = sequence.get('product_notebook')
invoice = sequence.get('invoice')
invoice_line = invoice.newContent(
id = 'invoice_line_%s'%(int(random.random()*1000)),
resource = product_notebook.getRelativeUrl(),
quantity = 10,
price = 10,
portal_type = self.sale_invoice_line_portal_type)
self.assertEqual(invoice_line.getTotalPrice(), 100)
sequence.edit(
invoice_line = invoice_line,
invoice_lines = [invoice_line]
)
def stepEditInvoiceLine(self, sequence, **kw) :
""" edit the invoice line :
10 notebook * 10 EUR, so total price is 100
"""
invoice = sequence.get('invoice')
invoice_line = sequence.get('invoice_line')
invoice_line.edit(
quantity = 10,
price = 10)
self.assertEqual(invoice_line.getTotalPrice(), 100)
def stepDeleteInvoiceLine(self, sequence, **kw) :
""" remove an invoice line from the invoice
"""
invoice = sequence.get('invoice')
invoice_line = sequence.get('invoice_line')
invoice.deleteContent([invoice_line.getId()])
def stepUpdateAppliedRule(self, sequence, **kw) :
""" update the applied rule for the invoice. In the UI, the call to
updateAppliedRule is made in an interraction workflow when you edit
an invoice or its content."""
sequence.get('invoice').updateAppliedRule(
rule_id='default_invoice_transaction_rule')
def stepCreateSimpleSaleInvoiceTwoLines(self, sequence, **kw) :
"""
similar to stepCreateSimpleSaleInvoice, but replace
......@@ -580,12 +677,14 @@ class TestAccountingRules(ERP5TypeTestCase):
id = 'invoice_line1',
resource = product_notebook.getRelativeUrl(),
quantity = 5,
price = 10)
price = 10,
portal_type = self.sale_invoice_line_portal_type)
invoice_line2 = simple_invoice.newContent(
id = 'invoice_line2',
resource = product_notebook.getRelativeUrl(),
REsource = product_notebook.getRelativeUrl(),
quantity = 5,
price = 10)
price = 10,
portal_type = self.sale_invoice_line_portal_type)
self.assertEqual(invoice_line1.getTotalPrice()
+ invoice_line2.getTotalPrice(), 100)
......@@ -596,16 +695,73 @@ class TestAccountingRules(ERP5TypeTestCase):
invoice_lines = [invoice_line1, invoice_line2]
)
def stepPlanInvoice(self, sequence, **kw) :
""" put the invoice in the `planned` state, which will
start the simulation process. """
invoice = sequence.get('invoice')
self.getPortal().portal_workflow.doActionFor(
invoice, 'plan_action',
wf_id = 'accounting_workflow'
def stepCreateSimpleSaleInvoiceTwoCells(self, sequence, **kw) :
"""
similar to stepCreateSimpleSaleInvoiceTwoLines, but use two
differents cells on the same line instead of two differents lines.
"""
vendor = sequence.get('vendor')
client = sequence.get('client')
product_notebook = sequence.get('product_notebook')
currency = sequence.get('currency')
simple_invoice = self.getAccountingModule().newContent(
id = 'simple_invoice_two_cells',
portal_type = self.sale_invoice_transaction_portal_type,
resource = currency.getRelativeUrl(),
stop_date = DateTime(2004, 01, 01),
start_date = DateTime(2004, 01, 01),
source_section = vendor.getRelativeUrl(),
destination_section = client.getRelativeUrl(),
)
invoice_line = simple_invoice.newContent(
id = 'invoice_line',
resource = product_notebook.getRelativeUrl(),
portal_type = self.sale_invoice_line_portal_type)
sequence.edit(
simple_invoice = simple_invoice,
invoice = simple_invoice,
invoice_line = invoice_line,
invoice_lines = [invoice_line]
)
self.assertEquals(invoice.getSimulationState(), 'planned')
self.stepAddCellsInInvoiceLine(sequence)
def stepAddCellsInInvoiceLine(self, sequence, **kw):
""" add 2 cells in the invoice line, same quantity as simple invoice
"""
invoice_line = sequence.get('invoice_line')
# initialy, the line must not contain cells
self.assertEqual(len(invoice_line.objectIds()), 0)
invoice_line._setVariationBaseCategoryList(['hd_size', 'cpu_freq'])
invoice_line._setVariationCategoryList(
['hd_size/60Go', 'hd_size/120Go', 'cpu_freq/1Ghz' ])
base_id = 'movement'
invoice_line.updateCellRange(base_id)
cell_key_list = list(invoice_line.getCellKeyList(base_id = base_id))
# this is probably not the easiest way to create cells ...
price = 10
quantity = 5
for cell_key in cell_key_list:
cell = invoice_line.newCell(base_id = base_id,
portal_type = self.sale_invoice_cell_portal_type, *cell_key)
cell.edit(mapped_value_property_list = ['price','quantity'],
price = price, quantity = quantity,
predicate_category_list = cell_key,
variation_category_list = cell_key)
# getTotalPrice uses mysql, so we must make sure the invoice is cataloged
# to have correct results
invoice_line.getParent().recursiveImmediateReindexObject()
self.assertEqual(invoice_line.getTotalPrice(), 100)
self.assertEqual(invoice_line.getTotalQuantity(), 10)
# then we must have 2 cells inside our line
self.assertEqual(len(invoice_line.objectIds()), 2)
def stepCreateMultiLineSaleInvoice(self, sequence, **kw) :
""" create an invoice with varianted products
The invoice is from `vendor` to `client_fr`, so the cell defined in
......@@ -943,10 +1099,93 @@ class TestAccountingRules(ERP5TypeTestCase):
self.assert_(len(rule_movement_found.keys()), 3)
sequence.edit( simulation_movement_list = simulation_movement_list )
def stepCollectSimulationMovements(self, sequence, **kw) :
""" put some simulation movements in sequence for later checkings """
invoice = sequence.get('invoice')
invoice_line = sequence.get('invoice_line')
applied_rule_list = self.getSimulationTool().contentValues()
self.assertEquals(len(applied_rule_list), 1)
simulation_movement_list = []
simulation_movement_quantities = {}
simulation_movement_resources = {}
simulation_movement_paths = {}
simulation_movement_section_paths = {}
applied_rule = applied_rule_list[0]
for invoice_simulation_movement in applied_rule.objectValues() :
for invoice_transaction_applied_rule in \
invoice_simulation_movement.objectValues() :
for simulation_movement in \
invoice_transaction_applied_rule.objectValues() :
path= simulation_movement.getPath()
simulation_movement_list.append(simulation_movement)
simulation_movement_quantities[path] = \
simulation_movement.getQuantity()
simulation_movement_resources[path] = \
simulation_movement.getResource()
simulation_movement_paths[path] = (
simulation_movement.getSource(),
simulation_movement.getDestination())
simulation_movement_section_paths[path] = (
simulation_movement.getSourceSection(),
simulation_movement.getDestinationSection())
sequence.edit(
simulation_movement_list = simulation_movement_list
, simulation_movement_quantities = simulation_movement_quantities
, simulation_movement_resources = simulation_movement_resources
, simulation_movement_paths = simulation_movement_paths
, simulation_movement_section_paths = simulation_movement_section_paths
)
def stepCheckSimulationMovements(self, sequence, **kw) :
""" checks simulation movements from the sequence object """
simulation_movement_list = sequence.get(
'simulation_movement_list')
simulation_movement_quantities = sequence.get(
'simulation_movement_quantities')
simulation_movement_resources = sequence.get(
'simulation_movement_resources')
simulation_movement_paths = sequence.get(
'simulation_movement_paths')
simulation_movement_section_paths = sequence.get(
'simulation_movement_section_paths')
for simulation_movement in simulation_movement_list :
path=simulation_movement.getPath()
self.assertEquals(
simulation_movement.getQuantity(),
simulation_movement_quantities[path]
)
self.assertEquals(
simulation_movement.getResource(),
simulation_movement_resources[path]
)
self.assertEquals(
(simulation_movement.getSource(), simulation_movement.getDestination()),
simulation_movement_paths[path]
)
self.assertEquals(
( simulation_movement.getSourceSection(),
simulation_movement.getDestinationSection()),
simulation_movement_section_paths[path]
)
def stepCheckPaymentRuleIsApplied(self, sequence, **kw) :
""" checks that a payment rule is applied for the total amount
of receivable """
# TODO
def stepPlanInvoice(self, sequence, **kw) :
""" put the invoice in the `planned` state, which will
start the simulation process. """
invoice = sequence.get('invoice')
self.getPortal().portal_workflow.doActionFor(
invoice, 'plan_action',
wf_id = 'accounting_workflow'
)
self.assertEquals(invoice.getSimulationState(), 'planned')
def stepConfirmInvoice(self, sequence, **kw) :
""" put the invoice in the `confirmed` state, which will
......@@ -1030,7 +1269,8 @@ class TestAccountingRules(ERP5TypeTestCase):
}
for invoice_transaction_line in invoice_transaction_line_list :
debit, credit = accounting_lines_layout[invoice_transaction_line.getSourceId()]
debit, credit = accounting_lines_layout[
invoice_transaction_line.getSourceId()]
self.assertEquals(debit, invoice_transaction_line.getSourceDebit())
self.assertEquals(credit, invoice_transaction_line.getSourceCredit())
......@@ -1068,10 +1308,52 @@ class TestAccountingRules(ERP5TypeTestCase):
}
for invoice_transaction_line in invoice_transaction_line_list :
debit, credit = accounting_lines_layout[invoice_transaction_line.getSourceId()]
debit, credit = accounting_lines_layout[
invoice_transaction_line.getSourceId()]
self.assertEquals(debit, invoice_transaction_line.getSourceDebit())
self.assertEquals(credit, invoice_transaction_line.getSourceCredit())
def stepRebuildAndCheckNothingIsCreated(self, sequence, **kw) :
""" Calls the DeliveryBuilder again and checks that the accounting module
remains unchanged.
"""
accounting_transaction_count = len(self.getAccountingModule().objectIds())
accounting_lines_dict = {}
for transaction in self.getAccountingModule().objectValues():
transaction_dict = {}
for accounting_line in transaction.objectValues() :
if accounting_line.getPortalType() != \
self.sale_invoice_line_portal_type :
transaction_dict[accounting_line.getId()] = \
accounting_line.getTotalQuantity()
accounting_lines_dict[transaction.getId()] = transaction_dict
# reindex the simulation for testing purposes
self.getSimulationTool().recursiveReindexObject()
self.tic()
delivery_tool = self.getPortal().portal_deliveries
# and build again ...
delivery_tool.sale_invoice_transaction_builder.build()
if hasattr(delivery_tool, 'pay_sheet_transaction_builder') :
# TODO: conflict with pay_sheet_transaction_builder must be tested too
delivery_tool.pay_sheet_transaction_builder.build()
self.tic()
# nothing should have changed
self.assertEquals(accounting_transaction_count,
len(self.getAccountingModule().objectIds()))
for transaction in self.getAccountingModule().objectValues() :
transaction_dict = accounting_lines_dict[transaction.getId()]
for accounting_line in transaction.objectValues() :
if accounting_line.getPortalType() != \
self.sale_invoice_line_portal_type :
self.assertEquals(
transaction_dict[accounting_line.getId()],
accounting_line.getTotalQuantity())
def test_01_HasEverything(self, quiet=0, run=RUN_ALL_TESTS):
""" check necessary tools and modules are present. """
if not run:
......@@ -1093,7 +1375,7 @@ class TestAccountingRules(ERP5TypeTestCase):
def test_02_UpdateInvoiceTransactionRuleMatrix(self, quiet=0,
run=RUN_ALL_TESTS):
"""
""" test edition of matrix and rule.
Try to update the matrix after adding some predicates,
and check if all objects were created
"""
......@@ -1117,8 +1399,7 @@ class TestAccountingRules(ERP5TypeTestCase):
def test_03_invoiceTransactionRule_getMatchingCell(self,
quiet=0, run=RUN_ALL_TESTS):
"""
test predicates for the cells of invoice transaction rule
""" test predicates for the cells of invoice transaction rule
"""
if not run:
return
......@@ -1144,7 +1425,7 @@ class TestAccountingRules(ERP5TypeTestCase):
""")
def test_04_SimpleInvoice(self, quiet=0, run=RUN_ALL_TESTS):
"""
""" Simple Invoice.
Try to expand an invoice containing only one simple Invoice Line.
Check that the build is correct.
"""
......@@ -1177,9 +1458,8 @@ class TestAccountingRules(ERP5TypeTestCase):
""" )
def test_04b_SimpleInvoiceConfirm(self, quiet=0, run=RUN_ALL_TESTS):
"""
Same test as SimpleInvoice but directly confirm the invoice without planning it
"""
""" Same test as SimpleInvoice but directly confirm the invoice
without planning it """
if not run:
return
if not quiet:
......@@ -1202,17 +1482,18 @@ class TestAccountingRules(ERP5TypeTestCase):
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_04c_SimpleInvoiceConfirm(self, quiet=0, run=RUN_ALL_TESTS):
"""
def test_04c_SimpleInvoiceTwoLines(self, quiet=0, run=RUN_ALL_TESTS):
""" Simple Invoice, 2 lines.
Same test as SimpleInvoice but use 2 lines of quantity 5 instead of
1 line of quantity 10.
"""
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (without plan)'
message = 'Test Simple Invoice Rule (with 2 lines)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
......@@ -1231,12 +1512,217 @@ class TestAccountingRules(ERP5TypeTestCase):
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_05_MultiLineInvoice(self, quiet=0, run=RUN_ALL_TESTS):
def test_04d_SimpleInvoiceTwoCells(self, quiet=0, run=RUN_ALL_TESTS):
""" Simple Invoice, 2 cells.
Same test as SimpleInvoice but use 2 cells of quantity 5 instead of
1 line of quantity 10.
"""
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (with 2 cells)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateSimpleSaleInvoiceTwoCells
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
# next 5 tests will check update of applied rules.
def test_05a_SimpleInvoiceReExpandAddLine(self, quiet=0,
run=RUN_BROKEN_TESTS):
""" Add a new line then updateAppliedRule.
Create an empty invoice, plan, add a line so that this
invoice is the same as `SimpleInvoice`, confirm it then check
accounting lines
"""
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (add invoice line and reexpand)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateEmptyInvoice
stepPlanInvoice
stepTic
stepAddInvoiceLine
stepUpdateAppliedRule
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_05b_SimpleInvoiceReExpandEditLine(self, quiet=0,
run = RUN_BROKEN_TESTS):
""" Tests that editing a line updates simulation correctly """
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (edit line and reexpand)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateOtherSimpleSaleInvoice
stepPlanInvoice
stepTic
stepCollectSimulationMovements
stepEditInvoiceLine
stepUpdateAppliedRule
stepConfirmInvoice
stepTic
stepCheckSimulationMovements
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_05c_SimpleInvoiceReExpandDeleteLine(
self, quiet=0, run=RUN_ALL_TESTS):
""" Tests that removing a line updates simulation correctly """
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (delete line and reexpand)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateSimpleSaleInvoice
stepAddInvoiceLine
stepPlanInvoice
stepTic
stepDeleteInvoiceLine
stepUpdateAppliedRule
stepTic
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_05d_SimpleInvoiceReExpandCreateCell(self, quiet=0,
run=RUN_BROKEN_TESTS):
""" Tests that replacing a line by cells updates simulation correctly """
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (add cells in a line and reexpand)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateOtherSimpleSaleInvoice
stepPlanInvoice
stepTic
stepAddCellsInInvoiceLine
stepUpdateAppliedRule
stepTic
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_05e_SimpleInvoiceExpandManyTimes(
self, quiet=0, run=RUN_ALL_TESTS):
""" Tests that updating an applied rule many times doesn't break the
build """
if not run:
return
if not quiet:
message = 'Test Simple Invoice Rule (many updateAppliedRule)'
ZopeTestCase._print('\n%s ' % message)
LOG('Testing... ', INFO, message)
self.playSequence("""
stepCreateAccounts
stepCreateEntities
stepCreateCurrencies
stepCreateProducts
stepCreateSaleInvoiceTransactionRule
stepUpdateSaleInvoiceTransactionRuleMatrix
stepCreateNotebookFranceCell
stepTic
stepClearSimulation
stepClearAccountingModule
stepCreateSimpleSaleInvoice
stepPlanInvoice
stepTic """ +
("""
stepEditInvoiceLine
stepUpdateAppliedRule
stepTic""" * 4) +
"""
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForSimpleInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_06_MultiLineInvoice(self, quiet=0, run=RUN_ALL_TESTS):
""" Multiple lines invoice.
Try to expand an invoice containing multiples Invoice Line.
Check that the build is correct, ie the movement are aggregated.
Check that the build is correct, ie similar movements are aggregated.
"""
if not run:
return
......@@ -1264,10 +1750,12 @@ class TestAccountingRules(ERP5TypeTestCase):
stepConfirmInvoice
stepTic
stepCheckAccountingLinesCreatedForMultiLineInvoice
stepRebuildAndCheckNothingIsCreated
""" )
def test_06_PaymentRuleForSaleInvoice(self, quiet=0, run=RUN_ALL_TESTS):
""" checks the payment rule is applied on sale invoice simulation
def test_07_PaymentRuleForSaleInvoice(self, quiet=0, run=RUN_ALL_TESTS):
""" Payment Rule.
checks the payment rule is applied on sale invoice simulation
movement. """
# checks :
# date from trade condition
......@@ -1282,3 +1770,4 @@ else:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestAccountingRules))
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