# -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (C) 2013 Therp BV (<http://therp.nl>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from datetime import datetime
from openerp.tests.common import TransactionCase
from openerp import workflow
class TestPaymentRoundtrip(TransactionCase):
def assert_payment_order_state(self, expected):
"""
Check that the state of our payment order is
equal to the 'expected' parameter
"""
state = self.registry('payment.order').read(
self.cr, self.uid, self.payment_order_id, ['state'])['state']
assert state == expected, \
'Payment order does not go into state \'%s\'.' % expected
def assert_invoices_state(self, expected):
"""
Check that the state of our invoices is
equal to the 'expected' parameter
"""
for invoice in self.registry('account.invoice').read(
self.cr, self.uid, self.invoice_ids, ['state']):
assert invoice['state'] == expected, \
'Invoice does not go into state \'%s\'' % expected
def setup_company(self, reg, cr, uid):
"""
Set up a company with a bank account and configure the
current user to work with that company
"""
data_model = reg('ir.model.data')
self.country_id = data_model.get_object_reference(
cr, uid, 'base', 'nl')[1]
self.currency_id = data_model.get_object_reference(
cr, uid, 'base', 'EUR')[1]
self.bank_id = reg('res.bank').create(
cr, uid, {
'name': 'ING Bank',
'bic': 'INGBNL2A',
'country': self.country_id,
})
self.company_id = reg('res.company').create(
cr, uid, {
'name': '_banking_addons_test_company',
'currency_id': self.currency_id,
'country_id': self.country_id,
})
self.partner_id = reg('res.company').read(
cr, uid, self.company_id, ['partner_id'])['partner_id'][0]
self.partner_bank_id = reg('res.partner.bank').create(
cr, uid, {
'state': 'iban',
'acc_number': 'NL08INGB0000000555',
'bank': self.bank_id,
'bank_bic': 'INGBNL2A',
'partner_id': self.partner_id,
'company_id': self.company_id,
})
reg('res.users').write(
cr, uid, [uid], {
'company_ids': [(4, self.company_id)]})
reg('res.users').write(
cr, uid, [uid], {
'company_id': self.company_id})
def setup_chart(self, reg, cr, uid):
"""
Set up the configurable chart of accounts and create periods
"""
data_model = reg('ir.model.data')
chart_setup_model = reg('wizard.multi.charts.accounts')
chart_template_id = data_model.get_object_reference(
cr, uid, 'account', 'configurable_chart_template')[1]
chart_values = {
'company_id': self.company_id,
'currency_id': self.currency_id,
'chart_template_id': chart_template_id}
chart_values.update(
chart_setup_model.onchange_chart_template_id(
cr, uid, [], 1)['value'])
chart_setup_id = chart_setup_model.create(
cr, uid, chart_values)
chart_setup_model.execute(
cr, uid, [chart_setup_id])
year = datetime.now().strftime('%Y')
fiscalyear_id = reg('account.fiscalyear').create(
cr, uid, {
'name': year,
'code': year,
'company_id': self.company_id,
'date_start': '%s-01-01' % year,
'date_stop': '%s-12-31' % year,
})
reg('account.fiscalyear').create_period(
cr, uid, [fiscalyear_id])
def setup_payables(self, reg, cr, uid, context=None):
"""
Set up suppliers and invoice them. Check that the invoices
can be validated properly.
"""
partner_model = reg('res.partner')
self.supplier1 = partner_model.create(
cr, uid, {
'name': 'Supplier 1',
'supplier': True,
'country_id': self.country_id,
'bank_ids': [
(0, False, {
'state': 'iban',
'acc_number': 'NL42INGB0000454000',
'bank': self.bank_id,
'bank_bic': 'INGBNL2A',
})
],
}, context=context)
self.supplier2 = partner_model.create(
cr, uid, {
'name': 'Supplier 2',
'supplier': True,
'country_id': self.country_id,
'bank_ids': [
(0, False, {
'state': 'iban',
'acc_number': 'NL86INGB0002445588',
'bank': self.bank_id,
'bank_bic': 'INGBNL2A',
})
],
}, context=context)
self.payable_id = reg('account.account').search(
cr, uid, [
('company_id', '=', self.company_id),
('code', '=', '120000')])[0]
expense_id = reg('account.account').search(
cr, uid, [
('company_id', '=', self.company_id),
('code', '=', '123000')])[0]
invoice_model = reg('account.invoice')
values = {
'type': 'in_invoice',
'partner_id': self.supplier1,
'account_id': self.payable_id,
'invoice_line': [
(0, False, {
'name': 'Purchase 1',
'price_unit': 100.0,
'quantity': 1,
'account_id': expense_id,
})
],
'reference_type': 'none',
'supplier_invoice_number': 'INV1',
}
self.invoice_ids = [
invoice_model.create(
cr, uid, values, context={
'type': 'in_invoice',
})]
values.update({
'partner_id': self.supplier2,
'name': 'Purchase 2',
'reference_type': 'structured',
'supplier_invoice_number': 'INV2',
'reference': 'STR2',
})
self.invoice_ids.append(
invoice_model.create(
cr, uid, values, context={
'type': 'in_invoice'}))
for invoice_id in self.invoice_ids:
workflow.trg_validate(
uid, 'account.invoice', invoice_id, 'invoice_open', cr)
self.assert_invoices_state('open')
def setup_payment_config(self, reg, cr, uid,
transfer_move_option='line'):
"""
Configure an additional account and journal for payments
in transit and configure a payment mode with them.
"""
account_parent_id = reg('account.account').search(
cr, uid, [
('company_id', '=', self.company_id),
('parent_id', '=', False)])[0]
user_type = reg('ir.model.data').get_object_reference(
cr, uid, 'account', 'data_account_type_liability')[1]
transfer_account_id = reg('account.account').create(
cr, uid, {
'company_id': self.company_id,
'parent_id': account_parent_id,
'code': 'TRANS',
'name': 'Transfer account',
'type': 'other',
'user_type': user_type,
'reconcile': True,
})
transfer_journal_id = reg('account.journal').search(
cr, uid, [
('company_id', '=', self.company_id),
('code', '=', 'MISC')])[0]
self.bank_journal_id = reg('account.journal').search(
cr, uid, [
('company_id', '=', self.company_id),
('type', '=', 'bank')])[0]
payment_mode_type_id = reg('ir.model.data').get_object_reference(
cr, uid, 'account_banking_sepa_credit_transfer',
'export_sepa_sct_001_001_03')[1]
self.payment_mode_id = reg('payment.mode').create(
cr, uid, {
'name': 'SEPA Mode',
'bank_id': self.partner_bank_id,
'journal': self.bank_journal_id,
'company_id': self.company_id,
'transfer_account_id': transfer_account_id,
'transfer_journal_id': transfer_journal_id,
'transfer_move_option': transfer_move_option,
'type': payment_mode_type_id,
})
def setup_payment(self, reg, cr, uid):
"""
Create a payment order with the invoices' payable move lines.
Check that the payment order can be confirmed.
date_preferred is set to 'now', to ensure one transfer move
when transfer_move_option = 'date'.
"""
self.payment_order_id = reg('payment.order').create(
cr, uid, {
'reference': 'PAY001',
'mode': self.payment_mode_id,
'date_prefered': 'now',
})
context = {
'active_id': self.payment_order_id,
'active_model': 'payment.order',
}
entries = reg('account.move.line').search(
cr, uid, [
('company_id', '=', self.company_id),
('account_id', '=', self.payable_id),
])
self.payment_order_create_id = reg('payment.order.create').create(
cr, uid, {
'entries': [(6, 0, entries)],
}, context=context)
reg('payment.order.create').create_payment(
cr, uid, [self.payment_order_create_id], context=context)
# Check if payment lines are created with the correct reference
self.assertTrue(
reg('payment.line').search(
cr, uid, [
('move_line_id.invoice', '=', self.invoice_ids[0]),
('communication', '=', 'INV1'),
('state', '=', 'normal'),
], context=context),
'No payment line created from invoice 1 or with the wrong '
'communication')
self.assertTrue(
reg('payment.line').search(
cr, uid, [
('move_line_id.invoice', '=', self.invoice_ids[1]),
('communication', '=', 'STR2'),
('state', '=', 'structured'),
], context=context),
'No payment line created from invoice 2 or with the wrong '
'communication')
workflow.trg_validate(
uid, 'payment.order', self.payment_order_id, 'open', cr)
self.assert_payment_order_state('open')
def export_payment(self, reg, cr, uid):
"""
Call the SEPA export wizard on the payment order
and check that the payment order and related invoices'
states are moved forward afterwards
"""
export_model = reg('banking.export.sepa.wizard')
export_id = export_model.create(
cr, uid, {}, context={'active_ids': [self.payment_order_id]})
export_model.create_sepa(
cr, uid, [export_id])
export_model.save_sepa(
cr, uid, [export_id])
self.assert_payment_order_state('sent')
self.assert_invoices_state('paid')
def setup_bank_statement(self, reg, cr, uid):
"""
Create a bank statement with a one line for each
payment order line. Call the reconciliation
wizard to match the line with the open payment order. Confirm the
bank statement. Check if the payment order is done.
"""
statement_model = reg('account.bank.statement')
line_model = reg('account.bank.statement.line')
statement_id = statement_model.create(
cr, uid, {
'name': 'Statement',
'journal_id': self.bank_journal_id,
'balance_end_real': -200.0,
'period_id': reg('account.period').find(cr, uid)[0]
})
line1_id = line_model.create(
cr, uid, {
'name': 'Statement line',
'statement_id': statement_id,
'amount': -100.0,
'account_id': self.payable_id,
'partner_id': self.supplier1,
})
line1 = line_model.browse(cr, uid, line1_id)
rec_line1 = line_model.\
get_reconciliation_proposition(cr, uid, line1)[0]
line_model.process_reconciliation(cr, uid, line1_id, [
{'counterpart_move_line_id': rec_line1['id'],
'debit': rec_line1['credit'],
'credit': rec_line1['debit']}])
line2_id = line_model.create(
cr, uid, {
'name': 'Statement line',
'statement_id': statement_id,
'amount': -100.0,
'account_id': self.payable_id,
'partner_id': self.supplier2,
})
line2 = line_model.browse(cr, uid, line2_id)
rec_line2 = line_model.\
get_reconciliation_proposition(cr, uid, line2)[0]
line_model.process_reconciliation(cr, uid, line2_id, [
{'counterpart_move_line_id': rec_line2['id'],
'debit': rec_line2['credit'],
'credit': rec_line2['debit']}])
self.assert_payment_order_state('done')
def setup_bank_statement_one_move(self, reg, cr, uid):
"""
Create a bank statement with a single line. Call the reconciliation
wizard to match the line with the open payment order. Confirm the
bank statement. Check if the payment order is done.
"""
statement_model = reg('account.bank.statement')
line_model = reg('account.bank.statement.line')
statement_id = statement_model.create(
cr, uid, {
'name': 'Statement',
'journal_id': self.bank_journal_id,
'balance_end_real': -200.0,
'period_id': reg('account.period').find(cr, uid)[0]
})
line1_id = line_model.create(
cr, uid, {
'name': 'Statement line',
'statement_id': statement_id,
'amount': -200.0,
'account_id': self.payable_id,
})
line1 = line_model.browse(cr, uid, line1_id)
rec_line1 = line_model.\
get_reconciliation_proposition(cr, uid, line1)[0]
line_model.process_reconciliation(cr, uid, line1_id, [
{'counterpart_move_line_id': rec_line1['id'],
'debit': rec_line1['credit'],
'credit': rec_line1['debit']}])
self.assert_payment_order_state('done')
def check_reconciliations(self, reg, cr, uid):
"""
Check if the payment order has any lines and that
the transit move lines of those payment lines are
reconciled by now.
The transit move line is the line that pays the invoice
so it is reconciled as soon as the payment order
is sent.
"""
payment_order = reg('payment.order').browse(
cr, uid, self.payment_order_id)
assert payment_order.line_ids, 'Payment order has no payment lines'
for line in payment_order.bank_line_ids:
assert line.transit_move_line_id, \
'Payment order has no transfer move line'
assert line.transit_move_line_id.reconcile_id, \
'Transit move line on payment line is not reconciled'
def check_reconciliations_after_bank_statement(self, reg, cr, uid):
"""
Check if the payment order has any lines and that
the transfer move lines of those payment lines are
reconciled by now.
"""
payment_order = reg('payment.order').browse(
cr, uid, self.payment_order_id)
assert payment_order.line_ids, 'Payment order has no payment lines'
for line in payment_order.bank_line_ids:
assert line.transfer_move_line_id, \
'Payment order has no transfer move line'
assert line.transfer_move_line_id.reconcile_id, \
'Transfer move line on payment line is not reconciled'
def test_payment_roundtrip(self):
""" Payment round trip using transfer account,
with one move per payment order line on the transfer account
"""
reg, cr, uid, = self.registry, self.cr, self.uid
self.setup_company(reg, cr, uid)
self.setup_chart(reg, cr, uid)
self.setup_payables(reg, cr, uid)
self.setup_payment_config(reg, cr, uid)
self.setup_payment(reg, cr, uid)
self.export_payment(reg, cr, uid)
self.check_reconciliations(reg, cr, uid)
self.setup_bank_statement(reg, cr, uid)
self.check_reconciliations_after_bank_statement(reg, cr, uid)
def test_payment_roundtrip_one_move(self):
""" Payment round trip using transfer account,
with one move per payment order on the transfer account
"""
reg, cr, uid, = self.registry, self.cr, self.uid
self.setup_company(reg, cr, uid)
self.setup_chart(reg, cr, uid)
self.setup_payables(reg, cr, uid)
self.setup_payment_config(reg, cr, uid, transfer_move_option='date')
self.setup_payment(reg, cr, uid)
self.export_payment(reg, cr, uid)
self.check_reconciliations(reg, cr, uid)
self.setup_bank_statement_one_move(reg, cr, uid)
self.check_reconciliations_after_bank_statement(reg, cr, uid)