forked from Mapan/odoo17e
785 lines
37 KiB
Python
785 lines
37 KiB
Python
# -*- coding: utf-8 -*-
|
|
from odoo.tests import tagged
|
|
from odoo.addons.account_consolidation.tests.account_consolidation_test_classes import AccountConsolidationTestCase
|
|
|
|
import json
|
|
from datetime import datetime, date
|
|
from unittest.mock import patch, ANY
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestConsolidationPeriod(AccountConsolidationTestCase):
|
|
# --- TESTS
|
|
|
|
def test_unlink(self):
|
|
AnalysisPeriod = self.env['consolidation.period']
|
|
CompanyPeriod = self.env['consolidation.company_period']
|
|
Composition = self.env['consolidation.period.composition']
|
|
Journal = self.env['consolidation.journal']
|
|
ap = self._create_analysis_period()
|
|
ap2 = self._create_analysis_period()
|
|
cp = self._generate_company_period(ap, 1, self.default_company)
|
|
composition = Composition.create({
|
|
'composed_period_id': ap.id,
|
|
'using_period_id': ap2.id
|
|
})
|
|
journal = Journal.create({
|
|
'name': 'BLAH',
|
|
'period_id': ap.id,
|
|
'chart_id': self.chart.id,
|
|
})
|
|
|
|
# CHECKING INITIAL CONDITIONS
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap.id)]), 1)
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap2.id)]), 1)
|
|
self.assertEqual(CompanyPeriod.search_count([('id', '=', cp.id)]), 1)
|
|
self.assertEqual(Composition.search_count([('id', '=', composition.id)]), 1)
|
|
self.assertEqual(Journal.search_count([('id', '=', journal.id)]), 1)
|
|
|
|
ap.unlink()
|
|
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap.id)]), 0)
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap2.id)]), 1)
|
|
self.assertEqual(CompanyPeriod.search_count([('id', '=', cp.id)]), 0)
|
|
self.assertEqual(Composition.search_count([('id', '=', composition.id)]), 0)
|
|
self.assertEqual(Journal.search_count([('id', '=', journal.id)]), 0)
|
|
|
|
ap3 = self._create_analysis_period()
|
|
composition2 = Composition.create({
|
|
'composed_period_id': ap3.id,
|
|
'using_period_id': ap2.id
|
|
})
|
|
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap3.id)]), 1)
|
|
self.assertEqual(Composition.search_count([('id', '=', composition2.id)]), 1)
|
|
|
|
ap2.unlink()
|
|
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap2.id)]), 0)
|
|
self.assertEqual(AnalysisPeriod.search_count([('id', '=', ap3.id)]), 1)
|
|
self.assertEqual(Composition.search_count([('id', '=', composition2.id)]), 0)
|
|
|
|
# ----- ACTIONS
|
|
|
|
def test_action_generate_journals(self):
|
|
Journal = self.env['consolidation.journal']
|
|
JournalLine = self.env['consolidation.journal.line']
|
|
self._create_consolidation_account('First', 'end')
|
|
self._create_consolidation_account('Second', 'avg')
|
|
|
|
ap = self._create_analysis_period()
|
|
self._generate_company_period(ap, 1, self.default_company)
|
|
self._generate_company_period(ap, 2, self.us_company)
|
|
|
|
# 1st state: from scratch
|
|
ap.action_generate_journals()
|
|
states = {'first': self._snapshot_state(ap.id)}
|
|
|
|
# 2nd state : regenerates
|
|
ap.action_generate_journals()
|
|
|
|
# Same amount of journal & journal lines as before
|
|
states['second'] = self._snapshot_state(ap.id)
|
|
|
|
self.assertDictEqual(states['first']['amounts'], states['second']['amounts'],
|
|
"The same amount of journals and journal lines should be linked to analysis period")
|
|
|
|
# old journals & journal lines have been deleted (and so new ones have been generated)
|
|
self.assertEqual(0, Journal.search_count([('id', 'in', states['first']['ids']['journal'])]),
|
|
"Old journals have been deleted (and so new ones have been generated")
|
|
self.assertEqual(0, JournalLine.search_count([('id', 'in', states['first']['ids']['journal_line'])]),
|
|
"Old journal lines have been deleted (and so new ones have been generated")
|
|
|
|
# 3rd state : locked ap
|
|
ap.action_close()
|
|
ap.action_generate_journals()
|
|
|
|
states['third'] = self._snapshot_state(ap.id)
|
|
|
|
self.assertDictEqual(states['second'], states['third'],
|
|
'Nothing should have changed as analysis period is locked')
|
|
|
|
# ----- PROTECTEDS
|
|
|
|
# TEST _get_company_periods_default_values
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriod._get_previous_similiar_period',
|
|
return_value=False)
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriod._get_company_periods_default_values_from_chart',
|
|
return_value=[])
|
|
def test__get_company_periods_default_values_to_chart(self, patched_get_company_values, patched_get_similar):
|
|
ap = self._create_analysis_period()
|
|
ap._get_company_periods_default_values()
|
|
self.assertTrue(patched_get_similar.called)
|
|
self.assertTrue(patched_get_company_values.called)
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriod._get_previous_similiar_period')
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriod._get_company_periods_default_values_from_period',
|
|
return_value=[])
|
|
def test__get_company_periods_default_values_to_period(self, patched_get_company_values, patched_get_similar):
|
|
ap = self._create_analysis_period()
|
|
patched_get_similar.return_value = ap
|
|
|
|
ap2 = self._create_analysis_period()
|
|
ap2._get_company_periods_default_values()
|
|
self.assertTrue(patched_get_similar.called)
|
|
self.assertTrue(patched_get_company_values.called)
|
|
patched_get_company_values.assert_called_with(ap)
|
|
|
|
def test__get_previous_similiar_period(self):
|
|
ap = self._create_analysis_period(chart=self.chart)
|
|
ap2 = self._create_analysis_period(chart=self.chart)
|
|
previous_similar = ap2._get_previous_similiar_period()
|
|
self.assertNotEqual(previous_similar, False)
|
|
self.assertEqual(previous_similar.id, ap.id)
|
|
|
|
def test__get_company_periods_default_values_from_period(self):
|
|
ap = self._create_analysis_period()
|
|
cps = (self._generate_company_period(ap, 1, self.default_company),
|
|
self._generate_company_period(ap, 2, self.us_company))
|
|
|
|
ap2 = self._create_analysis_period()
|
|
value_list = ap2._get_company_periods_default_values_from_period(ap)
|
|
self.assertEqual(len(value_list), len(cps))
|
|
fields = [
|
|
'date_company_begin',
|
|
'date_company_end',
|
|
'currency_rate_avg',
|
|
'currency_rate_end',
|
|
'rate_control',
|
|
'rate_ownership',
|
|
'rate_consolidation',
|
|
'consolidation_method'
|
|
]
|
|
for i, cp in enumerate(cps):
|
|
self.assertEqual(cp.company_id.id, value_list[i]['company_id'])
|
|
for field in fields:
|
|
self.assertEqual(getattr(cp, field), value_list[i][field])
|
|
|
|
def test__get_company_periods_default_values_from_chart(self):
|
|
ap = self._create_analysis_period(chart=self.chart)
|
|
values_list = ap._get_company_periods_default_values_from_chart()
|
|
self.assertEqual(len(values_list), len(self.chart.company_ids))
|
|
for values in values_list:
|
|
self.assertEqual(len(values), 10)
|
|
self.assertIn('chart_id', values)
|
|
self.assertIn('date_company_begin', values)
|
|
self.assertIn('date_company_end', values)
|
|
self.assertIn('company_id', values)
|
|
self.assertIn('currency_rate_avg', values)
|
|
self.assertIn('currency_rate_end', values)
|
|
self.assertIn('rate_control', values)
|
|
self.assertIn('rate_ownership', values)
|
|
self.assertIn('rate_consolidation', values)
|
|
self.assertIn('consolidation_method', values)
|
|
|
|
for company_id in self.chart.company_ids.ids:
|
|
index = -1
|
|
for i, values in enumerate(values_list):
|
|
if values['company_id'] == company_id:
|
|
index = i
|
|
self.assertNotEqual(index, -1, 'Default values for company %s should be generated' % company_id)
|
|
company_values = values_list[index]
|
|
self.assertEqual(company_values['chart_id'].id, self.chart.id)
|
|
self.assertEqual(company_values['date_company_begin'], ap.date_analysis_begin)
|
|
self.assertEqual(company_values['date_company_end'], ap.date_analysis_end)
|
|
|
|
def test__dashboard_sections(self):
|
|
AccountSection = self.env['consolidation.group']
|
|
ap = self._create_analysis_period()
|
|
sections = (
|
|
AccountSection.create({'name': 'Section 1', 'show_on_dashboard': True, 'chart_id': self.chart.id}),
|
|
AccountSection.create({'name': 'Section 2', 'show_on_dashboard': True, 'chart_id': self.chart.id}),
|
|
AccountSection.create(
|
|
{'name': 'Section Hidden', 'show_on_dashboard': False, 'chart_id': self.chart.id})
|
|
)
|
|
|
|
i = 1
|
|
step = 42
|
|
for section in sections:
|
|
accounts = (
|
|
self.env['consolidation.account'].create({'name': 'BLAH #' + str(i), 'group_id': section.id}),
|
|
self.env['consolidation.account'].create({'name': 'BLIH #' + str(i), 'group_id': section.id}))
|
|
for account in accounts:
|
|
journal = self.env['consolidation.journal'].create({
|
|
'name': 'BLAH',
|
|
'period_id': ap.id,
|
|
'chart_id': self.chart.id,
|
|
})
|
|
self.env['consolidation.journal.line'].create({
|
|
'account_id': account.id,
|
|
'journal_id': journal.id,
|
|
'amount': i * step
|
|
})
|
|
i += 1
|
|
|
|
excl_section = AccountSection.create({'name': 'Not listed section', 'chart_id': self.chart.id})
|
|
journal = self.env['consolidation.journal'].create({
|
|
'name': 'BLAH',
|
|
'period_id': self._create_analysis_period().id,
|
|
'chart_id': self.chart.id,
|
|
})
|
|
self.env['consolidation.journal.line'].create({
|
|
'account_id': self.env['consolidation.account'].create(
|
|
{'name': 'Excluded account', 'group_id': excl_section.id}).id,
|
|
'journal_id': journal.id
|
|
})
|
|
|
|
expected_amounts = [
|
|
ap._format_value(step + 2 * step), # i=1 & i=2 loop step
|
|
ap._format_value(3 * step + 4 * step) # i=3 & i=4 loop step
|
|
]
|
|
dashboard_sections = json.loads(ap.dashboard_sections)
|
|
self.assertListEqual([val.get('value') for val in dashboard_sections], expected_amounts)
|
|
self.assertEqual(list(map(lambda x: x.name, sections[:2])), [val.get('name') for val in dashboard_sections])
|
|
|
|
def test__journal_ids_count(self):
|
|
Journal = self.env['consolidation.journal']
|
|
ap = self._create_analysis_period()
|
|
amount_of_journals = 42
|
|
Journal.create([{'name': 'a', 'period_id': ap.id, 'chart_id': self.chart.id,}] * amount_of_journals)
|
|
self.assertEqual(ap.journal_ids_count, amount_of_journals)
|
|
|
|
def test__display_dates(self):
|
|
ap_same_month_and_year = self._create_analysis_period(start_date='2019-01-01', end_date='2019-01-31')
|
|
expected_str = ap_same_month_and_year.date_analysis_begin.strftime('%b %Y') # Jan 2019
|
|
self.assertEqual(ap_same_month_and_year.display_dates.lower(), expected_str.lower())
|
|
|
|
ap_same_month = self._create_analysis_period(start_date='2019-01-01', end_date='2020-01-31')
|
|
expected_str = '-'.join((ap_same_month.date_analysis_begin.strftime('%b %Y'), # Jan 2019-Jan 2020
|
|
ap_same_month.date_analysis_end.strftime('%b %Y')))
|
|
self.assertEqual(ap_same_month.display_dates.lower(), expected_str.lower())
|
|
|
|
ap_same_year = self._create_analysis_period(start_date='2019-01-01', end_date='2019-12-31')
|
|
expected_str = '-'.join((ap_same_year.date_analysis_begin.strftime('%b'), # Jan-Dec 2019
|
|
ap_same_year.date_analysis_end.strftime('%b %Y')))
|
|
self.assertEqual(ap_same_year.display_dates.lower(), expected_str.lower())
|
|
|
|
ap_nothing_common = self._create_analysis_period(start_date='2019-01-01', end_date='2020-06-01')
|
|
expected_str = '-'.join((ap_nothing_common.date_analysis_begin.strftime('%b %Y'), # Jan 2019-Jun 2020
|
|
ap_nothing_common.date_analysis_end.strftime('%b %Y')))
|
|
self.assertEqual(ap_nothing_common.display_dates.lower(), expected_str.lower())
|
|
|
|
# --- HELPERS
|
|
|
|
def _generate_company_period(self, ap, nb, company):
|
|
return self._create_company_period(period=ap, rate_consolidation=10 * nb, company=company)
|
|
|
|
def _snapshot_state(self, ap_id):
|
|
journals = self.env['consolidation.journal'].search([('period_id', '=', ap_id)])
|
|
journal_lines = self.env['consolidation.journal.line'].search([('period_id', '=', ap_id)])
|
|
return {
|
|
'ids': {
|
|
'journal': journals.ids,
|
|
'journal_line': journal_lines.ids,
|
|
},
|
|
'amounts': {
|
|
'journal': len(journals),
|
|
'journal_line': len(journal_lines),
|
|
}
|
|
}
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestConsolidationPeriodComposition(AccountConsolidationTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
# Child conso's
|
|
ap = self._create_analysis_period(chart=self.chart)
|
|
|
|
usd_chart = self.env['consolidation.chart'].create({'name': 'USD chart', 'currency_id': self.env.ref('base.USD').id})
|
|
usd_ap = self._create_analysis_period(chart=usd_chart)
|
|
# Children accounts
|
|
children_accounts = [
|
|
self._create_consolidation_account('Child account 1', chart=self.chart, section=None),
|
|
self._create_consolidation_account('Child account 2', chart=self.chart, section=None)
|
|
]
|
|
usd_children_accounts = [
|
|
self._create_consolidation_account('USD Child account 1', chart=usd_chart, section=None),
|
|
self._create_consolidation_account('USD Child account 2', chart=usd_chart, section=None)
|
|
]
|
|
# Account in child conso but not mapped to an account in super conso
|
|
other_account = self._create_consolidation_account('Child account 2', chart=self.chart, section=None)
|
|
|
|
# Parent/Super conso
|
|
super_chart = self.env['consolidation.chart'].create({'name': 'Super chart', 'currency_id': self.env.ref('base.EUR').id})
|
|
super_ap = self._create_analysis_period(chart=super_chart)
|
|
|
|
# Super account (in super conso)
|
|
self.super_account = self._create_consolidation_account('Super account', chart=super_chart, section=None)
|
|
|
|
# Link account to children accounts
|
|
self.super_account.write({'using_ids': [(6, 0, [ca.id for ca in children_accounts + usd_children_accounts])]})
|
|
|
|
# Link periods
|
|
Compo = self.env['consolidation.period.composition']
|
|
compo = Compo.create({
|
|
'composed_period_id': ap.id,
|
|
'rate_consolidation': 50.0,
|
|
'using_period_id': super_ap.id
|
|
})
|
|
usd_compo = Compo.create({
|
|
'composed_period_id': usd_ap.id,
|
|
'rate_consolidation': 20.0,
|
|
'currency_rate': 0.25,
|
|
'using_period_id': super_ap.id
|
|
})
|
|
|
|
# Create journal lines for each children accounts (and one for the other account but it won't affect the result)
|
|
self.env['consolidation.journal'].create({
|
|
'name': 'bluh',
|
|
'period_id': ap.id,
|
|
'auto_generated': True,
|
|
'chart_id': self.chart.id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': children_accounts[0].id,
|
|
'amount': 42
|
|
}),
|
|
(0, 0, {
|
|
'account_id': children_accounts[1].id,
|
|
'amount': 4200
|
|
}),
|
|
(0, 0, {
|
|
'account_id': other_account.id,
|
|
'amount': 420000
|
|
})
|
|
]
|
|
})
|
|
self.env['consolidation.journal'].create({
|
|
'name': 'USD bluh',
|
|
'period_id': usd_ap.id,
|
|
'auto_generated': True,
|
|
'chart_id': usd_chart.id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': usd_children_accounts[0].id,
|
|
'amount': 8000
|
|
}),
|
|
(0, 0, {
|
|
'account_id': usd_children_accounts[1].id,
|
|
'amount': 12000
|
|
})
|
|
]
|
|
})
|
|
self.compo = Compo.browse(compo.id)
|
|
self.usd_compo = Compo.browse(usd_compo.id)
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriod.action_generate_journals',
|
|
return_value=False)
|
|
def test_generate_journal(self, patched_ap_action_generate_journals):
|
|
AccountJournal = self.env['consolidation.journal']
|
|
self.compo._generate_journal()
|
|
# Checking that the journal generation of this composition triggers the generations of
|
|
# the composed analysis period
|
|
patched_ap_action_generate_journals.assert_called_once()
|
|
last_journal = AccountJournal.search([], order='id desc', limit=1)
|
|
|
|
self.assertEqual(last_journal.name, self.compo.composed_period_id.chart_name)
|
|
self.assertTrue(last_journal.auto_generated)
|
|
self.assertEqual(last_journal.composition_id, self.compo)
|
|
self.assertEqual(last_journal.period_id, self.compo.using_period_id)
|
|
self.assertEqual(len(last_journal.line_ids), 1)
|
|
amount_of_journals = AccountJournal.search_count([])
|
|
self.compo._generate_journal()
|
|
self.assertEqual(amount_of_journals, AccountJournal.search_count([]), 'Old journal has been deleted')
|
|
|
|
def test__get_journal_lines_values(self):
|
|
jl_values = self.compo._get_journal_lines_values()
|
|
self.assertEqual(len(jl_values), 1)
|
|
jl_value = jl_values[0]
|
|
self.assertEqual(jl_value['account_id'], self.super_account.id)
|
|
self.assertEqual(jl_value['amount'], 2121.0)
|
|
|
|
def test__get_total_amount(self):
|
|
# should be (4200 + 42) * 0.5 = 2121.0
|
|
self.assertAlmostEqual(self.compo._get_total_amount(self.super_account), 2121.0)
|
|
# should be ((12000 + 8000) * 0.2) * 0.25 = 1000.0
|
|
# consolidation rate currency_rate
|
|
self.assertAlmostEqual(self.usd_compo._get_total_amount(self.super_account), 1000.0)
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationPeriodComposition._get_default_currency_rate',
|
|
return_value=2.0)
|
|
def test__onchange_composed_chart_currency_id(self, mocked_method):
|
|
self.compo._onchange_composed_chart_currency_id()
|
|
self.usd_compo._onchange_composed_chart_currency_id()
|
|
self.assertFalse(self.compo.currencies_are_different)
|
|
self.assertTrue(self.usd_compo.currencies_are_different)
|
|
self.assertAlmostEqual(self.compo.currency_rate, 1.0)
|
|
self.assertAlmostEqual(self.usd_compo.currency_rate, mocked_method.return_value)
|
|
|
|
@patch('odoo.addons.base.models.res_currency.Currency._get_conversion_rate', return_value=150.0)
|
|
def test__get_default_currency_rate(self, mocked_method):
|
|
rate = self.usd_compo._get_default_currency_rate()
|
|
self.assertEqual(rate, mocked_method.return_value)
|
|
mocked_method.assert_called_once_with(self.usd_compo.composed_chart_currency_id,
|
|
self.usd_compo.using_chart_currency_id, self.env.company, ANY)
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestConsolidationCompanyPeriod(AccountConsolidationTestCase):
|
|
def test_get_display_name(self):
|
|
ap = self._create_analysis_period(start_date='2019-01-01', end_date='2019-01-31')
|
|
cp = self._create_company_period(period=ap, start_date='2019-01-01', end_date='2019-01-31')
|
|
expected_str = cp.company_name
|
|
self.assertEqual(expected_str, cp.display_name)
|
|
|
|
# SAME MONTH & YEAR
|
|
cp.write({
|
|
'date_company_begin': datetime.strptime('2019-02-01', '%Y-%m-%d'),
|
|
'date_company_end': datetime.strptime('2019-02-28', '%Y-%m-%d')
|
|
})
|
|
expected_str = cp.company_name + ' (' + cp.date_company_begin.strftime('%b %Y') + ')'
|
|
self.assertEqual(expected_str, cp.display_name)
|
|
|
|
# SAME MONTH BUT DIFFERENT YEAR
|
|
cp.write({
|
|
'date_company_begin': datetime.strptime('2019-01-01', '%Y-%m-%d'),
|
|
'date_company_end': datetime.strptime('2020-01-31', '%Y-%m-%d')
|
|
})
|
|
expected_str = cp.company_name + ' (' + '-'.join((cp.date_company_begin.strftime('%b %Y'), # Jan 2019-Jan 2020
|
|
cp.date_company_end.strftime('%b %Y'))) + ')'
|
|
self.assertEqual(expected_str, cp.display_name)
|
|
|
|
# SAME YEAR BUT DIFFERENT YEAR
|
|
cp.write({
|
|
'date_company_begin': datetime.strptime('2019-01-01', '%Y-%m-%d'),
|
|
'date_company_end': datetime.strptime('2019-12-31', '%Y-%m-%d')
|
|
})
|
|
expected_str = cp.company_name + ' (' + '-'.join((cp.date_company_begin.strftime('%b'), # # Jan-Dec 2019
|
|
cp.date_company_end.strftime('%b %Y'))) + ')'
|
|
self.assertEqual(expected_str, cp.display_name)
|
|
|
|
# DIFFERENT YEAR AND MONTH
|
|
cp.write({
|
|
'date_company_begin': datetime.strptime('2019-01-01', '%Y-%m-%d'),
|
|
'date_company_end': datetime.strptime('2020-06-01', '%Y-%m-%d')
|
|
})
|
|
expected_str = cp.company_name + ' (' + '-'.join((cp.date_company_begin.strftime('%b %Y'), # Jan 2019-Jun 2020
|
|
cp.date_company_end.strftime('%b %Y'))) + ')'
|
|
self.assertEqual(expected_str, cp.display_name)
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._get_total_balance_and_audit_lines',
|
|
return_value=(42.0, []))
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._apply_rates',
|
|
return_value=191289.0)
|
|
def test_generate_journal(self, patch_apply_rates, patched_get_total_balance):
|
|
Journal = self.env['consolidation.journal']
|
|
JournalLine = self.env['consolidation.journal.line']
|
|
self._create_consolidation_account('First', 'end')
|
|
self._create_consolidation_account('Second', 'avg')
|
|
|
|
ap = self._create_analysis_period()
|
|
cp = self._create_company_period(period=ap, rate_consolidation=10, company=self.default_company)
|
|
cp._generate_journal()
|
|
journals = Journal.search([('company_period_id', '=', cp.id)])
|
|
self.assertEqual(1, len(journals), "Company period should only have one Journal")
|
|
journal = journals[0]
|
|
self.assertEqual(journal.period_id.id, ap.id, "Created journal should have the right analysis period")
|
|
|
|
journal_lines = JournalLine.search([('journal_id', '=', journal.id)])
|
|
self.assertEqual(2, len(journal_lines), 'Generated journal should have two journal lines')
|
|
self.assertNotEqual(journal_lines[0].account_id, journal_lines[1].account_id,
|
|
'Generated journals lines should be linked to different accounts')
|
|
for journal_line in journal_lines:
|
|
self.assertAlmostEqual(journal_line.currency_amount, patched_get_total_balance.return_value[0],
|
|
msg='Generated journals should have the right currency amount')
|
|
self.assertAlmostEqual(journal_line.amount, patch_apply_rates.return_value,
|
|
msg='Generated journals should have the right amount')
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._get_total_balance_and_audit_lines',
|
|
return_value=(420.0, []))
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._apply_rates',
|
|
return_value=191289.0)
|
|
def test_get_journal_lines_values(self, patch_apply_rates, patch_get_total_balance):
|
|
accounts = (
|
|
self._create_consolidation_account('First', 'end'),
|
|
self._create_consolidation_account('Second', 'avg')
|
|
)
|
|
ap = self._create_analysis_period()
|
|
cps = (self._create_company_period(period=ap, rate_consolidation=10.0, company=self.default_company),
|
|
self._create_company_period(period=ap, rate_consolidation=20.0, company=self.us_company))
|
|
expected = [{
|
|
'account_id': accounts[0].id,
|
|
'amount': patch_apply_rates.return_value,
|
|
'currency_amount': patch_get_total_balance.return_value[0],
|
|
'move_line_ids': [(6, 0, patch_get_total_balance.return_value[1])]
|
|
}, {
|
|
'account_id': accounts[1].id,
|
|
'amount': patch_apply_rates.return_value,
|
|
'currency_amount': patch_get_total_balance.return_value[0],
|
|
'move_line_ids': [(6, 0, patch_get_total_balance.return_value[1])]}
|
|
]
|
|
for cp in cps:
|
|
result = cp._get_journal_lines_values()
|
|
self.assertListEqual(expected, result)
|
|
|
|
def test__apply_historical_rates(self):
|
|
ap = self._create_analysis_period()
|
|
consolidation_rate = 50
|
|
cp = self._create_company_period(period=ap, rate_consolidation=consolidation_rate,
|
|
company=self.us_company, start_date='2010-01-01', end_date='2024-12-31')
|
|
account_credit = self._create_account('111', 'Credit account', company=self.us_company)
|
|
consolidation_account = self._create_consolidation_account()
|
|
consolidation_account.write({'account_ids': [(4, account_credit.id)]})
|
|
move_date = '2014-01-31'
|
|
self.env['res.currency.rate'].create({
|
|
'name': move_date,
|
|
'company_id': self.us_company.id,
|
|
'currency_id': self.env.ref('base.EUR').id,
|
|
'rate': 0.8
|
|
})
|
|
self.env['res.currency.rate'].create({
|
|
'name': '2019-01-31',
|
|
'company_id': self.us_company.id,
|
|
'currency_id': self.env.ref('base.EUR').id,
|
|
'rate': 350.27
|
|
})
|
|
move = self._create_basic_move(1000, company=self.us_company, move_date=move_date,
|
|
account_credit=account_credit)
|
|
move_line = move.line_ids[0]
|
|
# = (50/100) * (mlb/1.25)
|
|
# = 0.5 * 0.8 * mlb
|
|
expected_amount = 0.4 * move_line.balance
|
|
self.assertAlmostEqual(cp._apply_historical_rates(move_line), expected_amount)
|
|
|
|
def test__apply_historical_rates_with_fixed_rates(self):
|
|
ap = self._create_analysis_period()
|
|
consolidation_rate = 50
|
|
cp = self._create_company_period(period=ap, rate_consolidation=consolidation_rate,
|
|
company=self.us_company, start_date='2010-01-01', end_date='2024-12-31')
|
|
self.env['consolidation.rate'].create([
|
|
{
|
|
'date_start': '2014-01-01',
|
|
'date_end': '2014-12-31',
|
|
'rate': 1.5,
|
|
'company_id': self.us_company.id,
|
|
'chart_id': cp.chart_id.id
|
|
},
|
|
{
|
|
'date_start': '2013-01-01',
|
|
'date_end': '2013-12-31',
|
|
'rate': 157.34,
|
|
'company_id': self.us_company.id,
|
|
'chart_id': cp.chart_id.id
|
|
},
|
|
{
|
|
'date_start': '2013-01-01',
|
|
'date_end': '2013-12-31',
|
|
'rate': 0.001,
|
|
'company_id': self.default_company.id,
|
|
'chart_id': cp.chart_id.id
|
|
}
|
|
])
|
|
account_credit = self._create_account('111', 'Credit account', company=self.us_company)
|
|
consolidation_account = self._create_consolidation_account()
|
|
consolidation_account.write({'account_ids': [(4, account_credit.id)]})
|
|
move_date = '2014-01-31'
|
|
self.env['res.currency.rate'].create({
|
|
'name': move_date,
|
|
'company_id': self.us_company.id,
|
|
'currency_id': self.us_company.currency_id.id,
|
|
'rate': 1.25
|
|
})
|
|
self.env['res.currency.rate'].create({
|
|
'name': '2019-01-31',
|
|
'company_id': self.us_company.id,
|
|
'currency_id': self.us_company.currency_id.id,
|
|
'rate': 350.27
|
|
})
|
|
move = self._create_basic_move(1000, company=self.us_company, move_date=move_date,
|
|
account_credit=account_credit)
|
|
move_line = move.line_ids[0]
|
|
# = (50/100) * (mlb*1.5) (1.5 = good rate above)
|
|
# = 0.75 * mlb
|
|
expected_amount = 0.75 * move_line.balance
|
|
self.assertAlmostEqual(cp._apply_historical_rates(move_line), expected_amount)
|
|
rate = self.env['consolidation.rate'].search([('rate', '=', 1.5)])
|
|
rate.rate = 3.0
|
|
# Check if the rate cache is properly invalidated
|
|
self.assertAlmostEqual(cp._apply_historical_rates(move_line), 1.5*move_line.balance)
|
|
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._convert')
|
|
@patch(
|
|
'odoo.addons.account_consolidation.models.consolidation_period.ConsolidationCompanyPeriod._apply_consolidation_rate')
|
|
def test__apply_rates(self, patched_apply_consolidation_rate, patched_convert):
|
|
cp = self._create_company_period(start_date='2019-01-01', end_date='2019-01-31', company=self.us_company)
|
|
ca = self._create_consolidation_account()
|
|
amount = 56554561
|
|
patched_convert.return_value = 15000
|
|
patched_apply_consolidation_rate.return_value = 13500
|
|
self.assertAlmostEqual(patched_apply_consolidation_rate.return_value, cp._apply_rates(amount, ca))
|
|
patched_convert.assert_called_once_with(amount, ca.currency_mode)
|
|
patched_apply_consolidation_rate.assert_called_once_with(patched_convert.return_value)
|
|
pass
|
|
|
|
def test__get_total_balance_and_audit_lines(self):
|
|
journals = {
|
|
'good': self.env['account.journal'].create({'name': 'Bank 123456', 'code': 'BNK67', 'type': 'bank',
|
|
'bank_acc_number': '123456', 'company_id': self.default_company.id}),
|
|
'ignored': self.env['account.journal'].create({'name': 'Outlier', 'code': 'OUT', 'type': 'bank',
|
|
'bank_acc_number': '12345226', 'company_id': self.default_company.id})
|
|
}
|
|
revenue_type = 'income'
|
|
dummy_account = self._create_account('003', 'NOTCONSIDERATED', company=self.default_company, type=revenue_type)
|
|
not_ignored_accounts = [
|
|
self._create_account('001', 'RCV', company=self.default_company, type=revenue_type),
|
|
self._create_account('002', 'RCV2', company=self.default_company, type=revenue_type),
|
|
]
|
|
conso_account = self.env['consolidation.account'].create({
|
|
'name': 'Test account',
|
|
'account_ids': [(4, x.id) for x in not_ignored_accounts]
|
|
})
|
|
|
|
cp = self._create_company_period(company=self.default_company)
|
|
cp.exclude_journal_ids = journals['ignored']
|
|
|
|
# The first move line should be ignored (because not in one of the accounts of the consolidation account)
|
|
not_ignored_amounts = [100, 1000]
|
|
right_move = self.env['account.move'].create({
|
|
'date': '2019-01-31',
|
|
'journal_id': journals['good'].id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': dummy_account.id,
|
|
'credit': sum(not_ignored_amounts)
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[0],
|
|
'debit': not_ignored_amounts[0]
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[1],
|
|
'debit': not_ignored_amounts[1]
|
|
}),
|
|
]
|
|
})
|
|
right_move.action_post()
|
|
|
|
# Ignored as not posted
|
|
self.env['account.move'].create({
|
|
'date': '2019-01-31',
|
|
'journal_id': journals['good'].id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': dummy_account.id,
|
|
'credit': sum(not_ignored_amounts)
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[0],
|
|
'debit': not_ignored_amounts[0]
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[1],
|
|
'debit': not_ignored_amounts[1]
|
|
}),
|
|
]
|
|
})
|
|
|
|
# All should be ignored as not in the period
|
|
self.env['account.move'].create({
|
|
'date': '2017-01-31',
|
|
'journal_id': journals['good'].id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': dummy_account.id,
|
|
'credit': 1100
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[0],
|
|
'debit': 100
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[1],
|
|
'debit': 1000
|
|
}),
|
|
]
|
|
}).action_post()
|
|
|
|
# All should be ignored as not in the right journal
|
|
self.env['account.move'].create({
|
|
'date': '2019-01-31',
|
|
'journal_id': journals['ignored'].id,
|
|
'line_ids': [
|
|
(0, 0, {
|
|
'account_id': dummy_account.id,
|
|
'credit': 1100
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[0],
|
|
'debit': 100
|
|
}),
|
|
(0, 0, {
|
|
'account_id': conso_account.mapped('account_ids.id')[1],
|
|
'debit': 1000
|
|
}),
|
|
]
|
|
}).action_post()
|
|
|
|
total_balance, associated_move_line_ids = cp._get_total_balance_and_audit_lines(conso_account)
|
|
self.assertAlmostEqual(sum(not_ignored_amounts), total_balance)
|
|
self.assertEqual(2, len(associated_move_line_ids))
|
|
for move_line_id in associated_move_line_ids:
|
|
self.assertEqual(self.env['account.move.line'].browse(move_line_id).move_id, right_move)
|
|
|
|
def test__get_move_lines(self):
|
|
journal = self._create_journal()
|
|
normal_type = 'income'
|
|
include_initial_balance_type = 'asset_receivable'
|
|
|
|
# NORMAL ACCOUNT AND CONSO ACCOUNT
|
|
normal_consolidation_account = self._create_consolidation_account()
|
|
normal_account = self._create_account('NOR', 'Normal account', type=normal_type)
|
|
normal_consolidation_account.write({'account_ids': [(4, normal_account.id)]})
|
|
|
|
# INCLUDE ACCOUNT AND CONSO ACCOUNT
|
|
include_consolidation_account = self._create_consolidation_account()
|
|
include_initial_account = self._create_account('INC', 'Normal account', type=include_initial_balance_type)
|
|
include_consolidation_account.write({'account_ids': [(4, include_initial_account.id)]})
|
|
|
|
cp = self._create_company_period(start_date='2019-01-01', end_date='2019-12-31', company=self.default_company)
|
|
|
|
# MOVES CREATION
|
|
# move before begin date
|
|
self._create_basic_move(9042, account_credit=normal_account, move_date=date(2012, 6, 30),
|
|
account_debit=include_initial_account, journal=journal, company=self.default_company)
|
|
# move after begin date
|
|
self._create_basic_move(42000, account_credit=normal_account, move_date=date(2019, 6, 30),
|
|
account_debit=include_initial_account, journal=journal, company=self.default_company)
|
|
|
|
# NORMAL
|
|
normal_domain = cp._get_move_lines_domain(normal_consolidation_account)
|
|
normal_move_lines = self.env['account.move.line'].search(normal_domain)
|
|
self.assertEqual(len(normal_move_lines), 1)
|
|
|
|
# INCLUDE INITIAL BALANCE
|
|
include_domain = cp._get_move_lines_domain(include_consolidation_account)
|
|
include_move_lines = self.env['account.move.line'].search(include_domain)
|
|
self.assertEqual(len(include_move_lines), 2)
|
|
|
|
def test__convert(self):
|
|
ap = self._create_analysis_period(start_date='2019-01-01', end_date='2019-01-31')
|
|
cp = self._create_company_period(period=ap, start_date='2019-01-01', end_date='2019-01-31')
|
|
rates = {'avg': 0.5, 'end': 0.35}
|
|
cp.write({'currency_rate_avg': rates['avg'], 'currency_rate_end': rates['end']})
|
|
|
|
amount = 15000
|
|
self.assertAlmostEqual(cp._convert(amount, 'avg'), amount / rates['avg'])
|
|
self.assertAlmostEqual(cp._convert(amount, 'end'), amount / rates['end'])
|
|
self.assertAlmostEqual(cp._convert(amount, 'hist'), amount)
|
|
self.assertAlmostEqual(cp._convert(amount, None), amount)
|
|
|
|
def test__apply_consolidation_rate(self):
|
|
cp = self._create_company_period(start_date='2019-01-01', end_date='2019-01-31', rate_consolidation=75.0)
|
|
self.assertAlmostEqual(cp._apply_consolidation_rate(1000.0), 750.0)
|