You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
218 lines
8.0 KiB
218 lines
8.0 KiB
# -*- coding: utf-8 -*-
|
|
# © 2014-2015 ACSONE SA/NV (<http://acsone.eu>)
|
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
|
|
|
|
import datetime
|
|
import time
|
|
|
|
from openerp import fields
|
|
import openerp.tests.common as common
|
|
from openerp.tools.safe_eval import safe_eval
|
|
|
|
from ..models.aep import AccountingExpressionProcessor as AEP
|
|
from ..models.accounting_none import AccountingNone
|
|
|
|
|
|
class TestAEP(common.TransactionCase):
|
|
|
|
def setUp(self):
|
|
super(TestAEP, self).setUp()
|
|
self.res_company = self.env['res.company']
|
|
self.account_model = self.env['account.account']
|
|
self.move_model = self.env['account.move']
|
|
self.journal_model = self.env['account.journal']
|
|
self.curr_year = datetime.date.today().year
|
|
self.prev_year = self.curr_year - 1
|
|
# create company
|
|
self.company = self.res_company.create({
|
|
'name': 'AEP Company'})
|
|
# create receivable bs account
|
|
type_ar = self.browse_ref('account.data_account_type_receivable')
|
|
self.account_ar = self.account_model.create({
|
|
'company_id': self.company.id,
|
|
'code': '400AR',
|
|
'name': 'Receivable',
|
|
'user_type_id': type_ar.id,
|
|
'reconcile': True})
|
|
# create income pl account
|
|
type_in = self.browse_ref('account.data_account_type_revenue')
|
|
self.account_in = self.account_model.create({
|
|
'company_id': self.company.id,
|
|
'code': '700IN',
|
|
'name': 'Income',
|
|
'user_type_id': type_in.id})
|
|
# create journal
|
|
self.journal = self.journal_model.create({
|
|
'company_id': self.company.id,
|
|
'name': 'Sale journal',
|
|
'code': 'VEN',
|
|
'type': 'sale'})
|
|
# create move in december last year
|
|
self._create_move(
|
|
date=datetime.date(self.prev_year, 12, 1),
|
|
amount=100,
|
|
debit_acc=self.account_ar,
|
|
credit_acc=self.account_in)
|
|
# create move in january this year
|
|
self._create_move(
|
|
date=datetime.date(self.curr_year, 1, 1),
|
|
amount=300,
|
|
debit_acc=self.account_ar,
|
|
credit_acc=self.account_in)
|
|
# create move in february this year
|
|
self._create_move(
|
|
date=datetime.date(self.curr_year, 3, 1),
|
|
amount=500,
|
|
debit_acc=self.account_ar,
|
|
credit_acc=self.account_in)
|
|
# create the AEP, and prepare the expressions we'll need
|
|
self.aep = AEP(self.env)
|
|
self.aep.parse_expr("bali[]")
|
|
self.aep.parse_expr("bale[]")
|
|
self.aep.parse_expr("balp[]")
|
|
self.aep.parse_expr("balu[]")
|
|
self.aep.parse_expr("bali[700IN]")
|
|
self.aep.parse_expr("bale[700IN]")
|
|
self.aep.parse_expr("balp[700IN]")
|
|
self.aep.parse_expr("bali[400AR]")
|
|
self.aep.parse_expr("bale[400AR]")
|
|
self.aep.parse_expr("balp[400AR]")
|
|
self.aep.done_parsing(self.company)
|
|
|
|
def _create_move(self, date, amount, debit_acc, credit_acc):
|
|
move = self.move_model.create({
|
|
'journal_id': self.journal.id,
|
|
'date': fields.Date.to_string(date),
|
|
'line_ids': [(0, 0, {
|
|
'name': '/',
|
|
'debit': amount,
|
|
'account_id': debit_acc.id,
|
|
}), (0, 0, {
|
|
'name': '/',
|
|
'credit': amount,
|
|
'account_id': credit_acc.id,
|
|
})]})
|
|
move.post()
|
|
return move
|
|
|
|
def _do_queries(self, date_from, date_to):
|
|
self.aep.do_queries(
|
|
date_from=fields.Date.to_string(date_from),
|
|
date_to=fields.Date.to_string(date_to),
|
|
target_move='posted',
|
|
company=self.company)
|
|
|
|
def _eval(self, expr):
|
|
eval_dict = {'AccountingNone': AccountingNone}
|
|
return safe_eval(self.aep.replace_expr(expr), eval_dict)
|
|
|
|
def _eval_by_account_id(self, expr):
|
|
res = {}
|
|
eval_dict = {'AccountingNone': AccountingNone}
|
|
for account_id, replaced_expr in \
|
|
self.aep.replace_expr_by_account_id(expr):
|
|
res[account_id] = safe_eval(replaced_expr, eval_dict)
|
|
return res
|
|
|
|
def test_sanity_check(self):
|
|
self.assertEquals(self.company.fiscalyear_last_day, 31)
|
|
self.assertEquals(self.company.fiscalyear_last_month, 12)
|
|
|
|
def test_aep_basic(self):
|
|
# let's query for december
|
|
self._do_queries(
|
|
datetime.date(self.prev_year, 12, 1),
|
|
datetime.date(self.prev_year, 12, 31))
|
|
# initial balance must be None
|
|
self.assertIs(self._eval('bali[400AR]'), AccountingNone)
|
|
self.assertIs(self._eval('bali[700IN]'), AccountingNone)
|
|
# check variation
|
|
self.assertEquals(self._eval('balp[400AR]'), 100)
|
|
self.assertEquals(self._eval('balp[700IN]'), -100)
|
|
# check ending balance
|
|
self.assertEquals(self._eval('bale[400AR]'), 100)
|
|
self.assertEquals(self._eval('bale[700IN]'), -100)
|
|
|
|
# let's query for January
|
|
self._do_queries(
|
|
datetime.date(self.curr_year, 1, 1),
|
|
datetime.date(self.curr_year, 1, 31))
|
|
# initial balance is None for income account (it's not carried over)
|
|
self.assertEquals(self._eval('bali[400AR]'), 100)
|
|
self.assertIs(self._eval('bali[700IN]'), AccountingNone)
|
|
# check variation
|
|
self.assertEquals(self._eval('balp[400AR]'), 300)
|
|
self.assertEquals(self._eval('balp[700IN]'), -300)
|
|
# check ending balance
|
|
self.assertEquals(self._eval('bale[400AR]'), 400)
|
|
self.assertEquals(self._eval('bale[700IN]'), -300)
|
|
|
|
# let's query for March
|
|
self._do_queries(
|
|
datetime.date(self.curr_year, 3, 1),
|
|
datetime.date(self.curr_year, 3, 31))
|
|
# initial balance is the ending balance fo January
|
|
self.assertEquals(self._eval('bali[400AR]'), 400)
|
|
self.assertEquals(self._eval('bali[700IN]'), -300)
|
|
# check variation
|
|
self.assertEquals(self._eval('balp[400AR]'), 500)
|
|
self.assertEquals(self._eval('balp[700IN]'), -500)
|
|
# check ending balance
|
|
self.assertEquals(self._eval('bale[400AR]'), 900)
|
|
self.assertEquals(self._eval('bale[700IN]'), -800)
|
|
|
|
# unallocated p&l from previous year
|
|
self.assertEquals(self._eval('balu[]'), -100)
|
|
|
|
# TODO allocate profits, and then...
|
|
|
|
def test_aep_by_account(self):
|
|
self._do_queries(
|
|
datetime.date(self.curr_year, 3, 1),
|
|
datetime.date(self.curr_year, 3, 31))
|
|
variation = self._eval_by_account_id('balp[]')
|
|
self.assertEquals(variation, {
|
|
self.account_ar.id: 500,
|
|
self.account_in.id: -500,
|
|
})
|
|
variation = self._eval_by_account_id('balp[700IN]')
|
|
self.assertEquals(variation, {
|
|
self.account_in.id: -500,
|
|
})
|
|
|
|
def test_aep_convenience_methods(self):
|
|
initial = AEP.get_balances(
|
|
AEP.MODE_INITIAL,
|
|
time.strftime('%Y') + '-03-01',
|
|
time.strftime('%Y') + '-03-31',
|
|
'posted',
|
|
self.company)
|
|
self.assertEquals(initial, {
|
|
self.account_ar.id: (400, 0),
|
|
self.account_in.id: (0, 300),
|
|
})
|
|
variation = AEP.get_balances(
|
|
AEP.MODE_VARIATION,
|
|
time.strftime('%Y') + '-03-01',
|
|
time.strftime('%Y') + '-03-31',
|
|
'posted',
|
|
self.company)
|
|
self.assertEquals(variation, {
|
|
self.account_ar.id: (500, 0),
|
|
self.account_in.id: (0, 500),
|
|
})
|
|
end = AEP.get_balances(
|
|
AEP.MODE_END,
|
|
time.strftime('%Y') + '-03-01',
|
|
time.strftime('%Y') + '-03-31',
|
|
'posted',
|
|
self.company)
|
|
self.assertEquals(end, {
|
|
self.account_ar.id: (900, 0),
|
|
self.account_in.id: (0, 800),
|
|
})
|
|
unallocated = AEP.get_unallocated_pl(
|
|
time.strftime('%Y') + '-03-01',
|
|
'posted',
|
|
self.company)
|
|
self.assertEquals(unallocated, (0, 100))
|