From 6185e81aa8be732fcab097770adb630378b2051a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9rome=20Perrin?= <jerome@nexedi.com> Date: Thu, 13 Mar 2008 18:16:20 +0000 Subject: [PATCH] reorganise tests and refactor to use AccountingTestCase git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@19878 20353a03-c40f-0410-a6d1-a30d3c3de9de --- product/ERP5/tests/testAccounting.py | 564 +++++++++++++++------------ 1 file changed, 308 insertions(+), 256 deletions(-) diff --git a/product/ERP5/tests/testAccounting.py b/product/ERP5/tests/testAccounting.py index 05426266d4..5a2f993e9f 100644 --- a/product/ERP5/tests/testAccounting.py +++ b/product/ERP5/tests/testAccounting.py @@ -192,12 +192,14 @@ class AccountingTestCase(ERP5TypeTestCase): get_transaction().abort() self.accounting_module.manage_delObjects( list(self.accounting_module.objectIds())) + organisation_list = ('my_organisation', 'client_1', 'client_2', 'supplier') self.organisation_module.manage_delObjects([x for x in - self.accounting_module.objectIds() if x not in ('my_organisation', - 'client_1', 'client_2', 'supplier')]) - self.organisation_module.my_organisation.manage_delObjects([x.getId() - for x in self.organisation_module.my_organisation.objectValues( - portal_type=('Accounting Period', 'Bank Account'))]) + self.accounting_module.objectIds() if x not in organisation_list]) + for organisation_id in organisation_list: + organisation = self.organisation_module._getOb(organisation_id) + organisation.manage_delObjects([x.getId() for x in + organisation.objectValues( + portal_type=('Accounting Period', 'Bank Account'))]) self.person_module.manage_delObjects([x for x in self.person_module.objectIds() if x not in ('john_smith',)]) self.account_module.manage_delObjects([x for x in @@ -475,7 +477,34 @@ class TestTransactionValidation(AccountingTestCase): line.setDestinationAssetDebit(38.99) self.portal.portal_workflow.doActionFor(transaction, 'stop_action') + def test_AccountingTransactionValidationRefusedWithCategoriesAsSections(self): + # Validating a transaction with categories as sections is refused. + # See http://wiki.erp5.org/Discussion/AccountingProblems + category = self.section.getGroupValue() + self.assertNotEquals(category, None) + transaction = self._makeOne( + portal_type='Accounting Transaction', + start_date=DateTime('2007/01/02'), + source_section_value=category, + destination_section_value=self.organisation_module.client_1, + resource='currency_module/yen', + lines=(dict(source_value=self.account_module.payable, + source_debit=500), + dict(source_value=self.account_module.receivable, + source_credit=500))) + self.assertRaises(ValidationFailed, + self.portal.portal_workflow.doActionFor, + transaction, 'stop_action') + transaction.setSourceSectionValue(self.section) + transaction.setDestinationSectionValue(category) + self.assertRaises(ValidationFailed, + self.portal.portal_workflow.doActionFor, + transaction, 'stop_action') + + transaction.setDestinationSectionValue(self.organisation_module.client_1) + self.portal.portal_workflow.doActionFor(transaction, 'stop_action') + def test_AccountingWorkflow(self): transaction = self._makeOne( portal_type='Accounting Transaction', @@ -1637,7 +1666,278 @@ class TestAccountingExport(AccountingTestCase): self.assertFalse('???' in content_xml) -class TestAccounting(ERP5TypeTestCase): +class TestTransactions(AccountingTestCase): + """Test behaviours and utility scripts for Accounting Transactions. + """ + + def test_SourceDestinationReference(self): + # Check that source reference and destination reference are filled + # automatically. + + # clear all existing ids in portal ids + if hasattr(self.portal.portal_ids, 'dict_ids'): + self.portal.portal_ids.dict_ids.clear() + section_period_2001 = self.section.newContent( + portal_type='Accounting Period', + short_title='code-2001', + start_date=DateTime(2001, 01, 01), + stop_date=DateTime(2001, 12, 31)) + section_period_2001.start() + section_period_2002 = self.section.newContent( + portal_type='Accounting Period', + short_title='code-2002', + start_date=DateTime(2002, 01, 01), + stop_date=DateTime(2002, 12, 31)) + section_period_2002.start() + + accounting_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_1, + start_date=DateTime(2001, 01, 01), + stop_date=DateTime(2001, 01, 01)) + self.portal.portal_workflow.doActionFor( + accounting_transaction, 'stop_action') + # The reference generated for the source section uses the short title from + # the accounting period + self.assertEquals('code-2001-1', accounting_transaction.getSourceReference()) + # This works, because we use + # 'AccountingTransaction_getAccountingPeriodForSourceSection' script + self.assertEquals(section_period_2001, accounting_transaction\ + .AccountingTransaction_getAccountingPeriodForSourceSection()) + # If no accounting period exists on this side, the transaction date is + # used. + self.assertEquals('2001-1', accounting_transaction.getDestinationReference()) + + other_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_2, + start_date=DateTime(2001, 01, 01), + stop_date=DateTime(2001, 01, 01)) + self.portal.portal_workflow.doActionFor(other_transaction, 'stop_action') + self.assertEquals('code-2001-2', other_transaction.getSourceReference()) + self.assertEquals('2001-1', other_transaction.getDestinationReference()) + + next_year_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_1, + start_date=DateTime(2002, 01, 01), + stop_date=DateTime(2002, 01, 01)) + self.portal.portal_workflow.doActionFor(next_year_transaction, 'stop_action') + self.assertEquals('code-2002-1', next_year_transaction.getSourceReference()) + self.assertEquals('2002-1', next_year_transaction.getDestinationReference()) + + def test_SearchableText(self): + transaction = self._makeOne(title='A new Transaction', + description="A description", + comment="Some comments") + searchable_text = transaction.SearchableText() + self.assertTrue('A new Transaction' in searchable_text) + self.assertTrue('A description' in searchable_text) + self.assertTrue('Some comments' in searchable_text) + + def test_GroupingReferenceResetedOnCopyPaste(self): + accounting_module = self.portal.accounting_module + for portal_type in self.portal.getPortalAccountingTransactionTypeList(): + if portal_type == 'Balance Transaction': + # Balance Transaction cannot be copy and pasted, because they are not + # in visible allowed types. + continue + transaction = accounting_module.newContent( + portal_type=portal_type) + line = transaction.newContent( + id = 'line_with_grouping_reference', + grouping_reference='A', + portal_type=transaction_to_line_mapping[portal_type]) + + cp = accounting_module.manage_copyObjects(ids=[transaction.getId()]) + copy_id = accounting_module.manage_pasteObjects(cp)[0]['new_id'] + self.failIf(accounting_module[copy_id]\ + .line_with_grouping_reference.getGroupingReference()) + + + # tests for Invoice_createRelatedPaymentTransaction + def _checkRelatedSalePayment(self, invoice, payment, payment_node, quantity): + """Check payment of a Sale Invoice. + """ + eq = self.assertEquals + eq('Payment Transaction', payment.getPortalTypeName()) + eq([invoice], payment.getCausalityValueList()) + eq(invoice.getSourceSection(), payment.getSourceSection()) + eq(invoice.getDestinationSection(), payment.getDestinationSection()) + eq(payment_node, payment.getSourcePaymentValue()) + eq(self.getCategoryTool().payment_mode.check, + payment.getPaymentModeValue()) + # test lines + eq(2, len(payment.getMovementList())) + for line in payment.getMovementList(): + if line.getId() == 'bank': + eq(quantity, line.getSourceCredit()) + eq(self.account_module.bank, line.getSourceValue()) + else: + eq(quantity, line.getSourceDebit()) + eq(self.account_module.receivable, line.getSourceValue()) + # this transaction can be validated + eq([], payment.checkConsistency()) + self.portal.portal_workflow.doActionFor(payment, 'stop_action') + eq('stopped', payment.getSimulationState()) + + def test_Invoice_createRelatedPaymentTransactionSimple(self): + # Simple case of creating a related payment transaction. + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=100))) + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 100) + + def test_Invoice_createRelatedPaymentTransactionGroupedLines(self): + # Simple creating a related payment transaction when grouping reference of + # some lines is already set. + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=60), + dict(source_value=self.account_module.receivable, + source_credit=40, + grouping_reference='A'),)) + + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 60) + + def test_Invoice_createRelatedPaymentTransactionDifferentSection(self): + # Simple creating a related payment transaction when we have two line for + # 2 different destination sections. + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=60), + dict(source_value=self.account_module.receivable, + source_credit=40, + destination_section_value=self.organisation_module.client_2),)) + + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 60) + + def test_Invoice_createRelatedPaymentTransactionRelatedInvoice(self): + # Simple creating a related payment transaction when we have related + # transactions. + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=100),)) + accounting_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_1, + causality_value=invoice, + lines=(dict(source_value=self.account_module.goods_purchase, + source_credit=20), + dict(source_value=self.account_module.receivable, + source_debit=20),)) + + accounting_transaction.setCausalityValue(invoice) + self.portal.portal_workflow.doActionFor(accounting_transaction, + 'stop_action') + self.assertEquals('stopped', accounting_transaction.getSimulationState()) + get_transaction().commit() + self.tic() + + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 80) + + def test_Invoice_createRelatedPaymentTransactionRelatedInvoiceDifferentSide(self): + # Simple creating a related payment transaction when we have related + # transactions with different side + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=100),)) + accounting_transaction = self._makeOne( + source_section_value=self.organisation_module.client_1, + destination_section_value=self.section, + causality_value=invoice, + lines=(dict(destination_value=self.account_module.goods_purchase, + destination_credit=20), + dict(destination_value=self.account_module.receivable, + destination_debit=20),)) + self.portal.portal_workflow.doActionFor(accounting_transaction, + 'stop_action') + self.assertEquals('stopped', accounting_transaction.getSimulationState()) + get_transaction().commit() + self.tic() + + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 80) + + def test_Invoice_createRelatedPaymentTransactionRelatedInvoiceDraft(self): + # Simple creating a related payment transaction when we have related + # transactions in draft/cancelled state (they are ignored) + payment_node = self.section.newContent(portal_type='Bank Account') + invoice = self._makeOne( + destination_section_value=self.organisation_module.client_1, + lines=(dict(source_value=self.account_module.goods_purchase, + source_debit=100), + dict(source_value=self.account_module.receivable, + source_credit=100),)) + accounting_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_1, + causality_value=invoice, + lines=(dict(source_value=self.account_module.goods_purchase, + source_credit=20), + dict(source_value=self.account_module.receivable, + source_debit=20),)) + + other_accounting_transaction = self._makeOne( + destination_section_value=self.organisation_module.client_1, + causality_value=invoice, + lines=(dict(source_value=self.account_module.goods_purchase, + source_credit=20), + dict(source_value=self.account_module.receivable, + source_debit=20),)) + + other_accounting_transaction.cancel() + get_transaction().commit() + self.tic() + + payment = invoice.Invoice_createRelatedPaymentTransaction( + node=self.account_module.bank.getRelativeUrl(), + payment=payment_node.getRelativeUrl(), + payment_mode='check', + batch_mode=1) + self._checkRelatedSalePayment(invoice, payment, payment_node, 100) + + +class TestAccountingWithSequences(ERP5TypeTestCase): """The first test for Accounting """ def getAccountingModule(self): @@ -2815,255 +3115,6 @@ class TestAccounting(ERP5TypeTestCase): stepValidateRemoveEmptyLines """, quiet=quiet) - def test_AccountingTransactionValidationRefusedWithCategoriesAsSections(self, - quiet=QUIET, run=RUN_ALL_TESTS): - """Validating a transaction with categories as sections is refused. - See http://wiki.erp5.org/Discussion/AccountingProblems """ - category = self.vendor.getGroupValue() - self.assertNotEquals(category, None) - transaction = self.createAccountingTransaction( - source_section_value=category, - check_consistency=0) - self.assertRaises(ValidationFailed, self.getWorkflowTool().doActionFor, - transaction, 'stop_action') - transaction = self.createAccountingTransaction( - destination_section_value=category, - check_consistency=0) - self.assertRaises(ValidationFailed, self.getWorkflowTool().doActionFor, - transaction, 'stop_action') - - # tests for Invoice_createRelatedPaymentTransaction - def _checkRelatedSalePayment(self, invoice, payment, payment_node, quantity): - """Check payment of a Sale Invoice. - """ - eq = self.assertEquals - eq('Payment Transaction', payment.getPortalTypeName()) - eq([invoice], payment.getCausalityValueList()) - eq(invoice.getSourceSection(), payment.getSourceSection()) - eq(invoice.getDestinationSection(), payment.getDestinationSection()) - eq(payment_node, payment.getSourcePaymentValue()) - eq(self.getCategoryTool().payment_mode.check, - payment.getPaymentModeValue()) - # test lines - eq(2, len(payment.getMovementList())) - for line in payment.getMovementList(): - if line.getId() == 'bank': - eq(quantity, line.getSourceCredit()) - eq(self.bank_account, line.getSourceValue()) - else: - eq(quantity, line.getSourceDebit()) - eq(self.receivable_account, line.getSourceValue()) - # this transaction can be validated - eq([], payment.checkConsistency()) - self.workflow_tool.doActionFor(payment, 'stop_action') - eq('stopped', payment.getSimulationState()) - - def test_Invoice_createRelatedPaymentTransactionSimple(self): - """Simple case of creating a related payment transaction. - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 100) - - def test_Invoice_createRelatedPaymentTransactionGroupedLines(self): - """Simple creating a related payment transaction when grouping reference of - some lines is already set. - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - invoice.receivable.setSourceCredit(60) - invoice.newContent(id='receivable_groupped', - source_credit=40, - source_value=self.receivable_account) - invoice.receivable_groupped.setGroupingReference('A') - - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 60) - - def test_Invoice_createRelatedPaymentTransactionDifferentSection(self): - """Simple creating a related payment transaction when we have two line for - 2 different destination sections. - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - invoice.receivable.setSourceCredit(60) - invoice.newContent(id='receivable_other_third_party', - destination_section_value=self.other_vendor, - source_credit=40, - source_value=self.receivable_account) - - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 60) - - def test_Invoice_createRelatedPaymentTransactionRelatedInvoice(self): - """Simple creating a related payment transaction when we have related - transactions. - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - accounting_transaction = self.createAccountingTransaction() - accounting_transaction.receivable.setSourceDebit(20) - accounting_transaction.income.setSourceCredit(20) - accounting_transaction.setCausalityValue(invoice) - self.portal.portal_workflow.doActionFor(accounting_transaction, - 'stop_action') - self.assertEquals('stopped', accounting_transaction.getSimulationState()) - get_transaction().commit() - self.tic() - - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 80) - - def test_Invoice_createRelatedPaymentTransactionRelatedInvoiceDifferentSide(self): - """Simple creating a related payment transaction when we have related - transactions with different side - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - accounting_transaction = self.createAccountingTransaction() - accounting_transaction.edit( - source_section=accounting_transaction.getDestinationSection(), - destination_section=accounting_transaction.getSourceSection()) - accounting_transaction.receivable.edit( - source=accounting_transaction.receivable.getDestination(), - destination=accounting_transaction.receivable.getSource(), - destination_debit=20) - accounting_transaction.income.edit( - source=accounting_transaction.income.getDestination(), - destination=accounting_transaction.income.getSource(), - destination_credit=20) - accounting_transaction.setCausalityValue(invoice) - self.portal.portal_workflow.doActionFor(accounting_transaction, - 'stop_action') - self.assertEquals('stopped', accounting_transaction.getSimulationState()) - get_transaction().commit() - self.tic() - - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 80) - - def test_Invoice_createRelatedPaymentTransactionRelatedInvoiceDraft(self): - """Simple creating a related payment transaction when we have related - transactions in draft/cancelled state (they are ignored) - """ - payment_node = self.vendor.newContent(portal_type='Bank Account') - invoice = self.createAccountingTransaction() - accounting_transaction = self.createAccountingTransaction() - accounting_transaction.setCausalityValue(invoice) - other_accounting_transaction = self.createAccountingTransaction() - other_accounting_transaction.setCausalityValue(invoice) - other_accounting_transaction.cancel() - get_transaction().commit() - self.tic() - - payment = invoice.Invoice_createRelatedPaymentTransaction( - node=self.bank_account.getRelativeUrl(), - payment=payment_node.getRelativeUrl(), - payment_mode='check', - batch_mode=1) - self._checkRelatedSalePayment(invoice, payment, payment_node, 100) - - def test_SourceDestinationReference(self): - """Check that source reference and destination reference are filled - automatically. - """ - # clear all existing ids in portal ids - if hasattr(self.portal.portal_ids, 'dict_ids'): - self.portal.portal_ids.dict_ids.clear() - section_period_2001 = self.section.newContent( - portal_type='Accounting Period', - short_title='code-2001', - start_date=DateTime(2001, 01, 01), - stop_date=DateTime(2001, 12, 31)) - section_period_2001.start() - section_period_2002 = self.section.newContent( - portal_type='Accounting Period', - short_title='code-2002', - start_date=DateTime(2002, 01, 01), - stop_date=DateTime(2002, 12, 31)) - section_period_2002.start() - - accounting_transaction = self.createAccountingTransaction( - start_date=DateTime(2001, 01, 01), - stop_date=DateTime(2001, 01, 01)) - self.portal.portal_workflow.doActionFor( - accounting_transaction, 'stop_action') - # The reference generated for the source section uses the short title from - # the accounting period - self.assertEquals('code-2001-1', accounting_transaction.getSourceReference()) - # This works, because we use - # 'AccountingTransaction_getAccountingPeriodForSourceSection' script - self.assertEquals(section_period_2001, accounting_transaction\ - .AccountingTransaction_getAccountingPeriodForSourceSection()) - # If no accounting period exists on this side, the transaction date is - # used. - self.assertEquals('2001-1', accounting_transaction.getDestinationReference()) - - other_transaction = self.createAccountingTransaction( - start_date=DateTime(2001, 01, 01), - stop_date=DateTime(2001, 01, 01)) - other_transaction.setDestinationSectionValue(self.other_vendor) - self.portal.portal_workflow.doActionFor(other_transaction, 'stop_action') - self.assertEquals('code-2001-2', other_transaction.getSourceReference()) - self.assertEquals('2001-1', other_transaction.getDestinationReference()) - - next_year_transaction = self.createAccountingTransaction( - start_date=DateTime(2002, 01, 01), - stop_date=DateTime(2002, 01, 01)) - self.portal.portal_workflow.doActionFor(next_year_transaction, 'stop_action') - self.assertEquals('code-2002-1', next_year_transaction.getSourceReference()) - self.assertEquals('2002-1', next_year_transaction.getDestinationReference()) - - def test_SearchableText(self): - transaction = self.createAccountingTransaction() - transaction.edit(title='A new Transaction', - description="A description", - comment="Some comments") - searchable_text = transaction.SearchableText() - self.assertTrue('A new Transaction' in searchable_text) - self.assertTrue('A description' in searchable_text) - self.assertTrue('Some comments' in searchable_text) - - def test_GroupingReferenceResetedOnCopyPaste(self): - accounting_module = self.portal.accounting_module - for portal_type in self.portal.getPortalAccountingTransactionTypeList(): - if portal_type == 'Balance Transaction': - # Balance Transaction cannot be copy and pasted, because they are not - # in visible allowed types. - continue - transaction = accounting_module.newContent( - portal_type=portal_type) - line = transaction.newContent( - id = 'line_with_grouping_reference', - grouping_reference='A', - portal_type=transaction_to_line_mapping[portal_type]) - - cp = accounting_module.manage_copyObjects(ids=[transaction.getId()]) - copy_id = accounting_module.manage_pasteObjects(cp)[0]['new_id'] - self.failIf(accounting_module[copy_id]\ - .line_with_grouping_reference.getGroupingReference()) - class TestAccountingTransactionTemplate(AccountingTestCase): """A test for Accounting Transaction Template @@ -3115,7 +3166,8 @@ class TestAccountingTransactionTemplate(AccountingTestCase): def test_suite(): suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(TestAccounting)) + suite.addTest(unittest.makeSuite(TestAccountingWithSequences)) + suite.addTest(unittest.makeSuite(TestTransactions)) suite.addTest(unittest.makeSuite(TestAccounts)) suite.addTest(unittest.makeSuite(TestClosingPeriod)) suite.addTest(unittest.makeSuite(TestTransactionValidation)) -- 2.30.9