644 lines
27 KiB
Python
644 lines
27 KiB
Python
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
|
|
import logging
|
|
|
|
from odoo import fields
|
|
from odoo.tests import common
|
|
from odoo.tools import mute_logger
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class TestAccountChartUpdate(common.HttpCase):
|
|
at_install = False
|
|
post_install = True
|
|
|
|
def _create_xml_id(self, record):
|
|
return self.env["ir.model.data"].create(
|
|
{
|
|
"module": "account_chart_update",
|
|
"name": "{}-{}".format(record._table, record.id),
|
|
"model": record._name,
|
|
"res_id": record.id,
|
|
}
|
|
)
|
|
|
|
def _create_account_tmpl(self, name, code, account_type, chart_template):
|
|
record = self.env["account.account.template"].create(
|
|
{
|
|
"name": name,
|
|
"code": code,
|
|
"account_type": account_type,
|
|
"chart_template_id": chart_template and chart_template.id,
|
|
}
|
|
)
|
|
self._create_xml_id(record)
|
|
return record
|
|
|
|
def _create_tax_tmpl(self, name, chart_template):
|
|
record = self.env["account.tax.template"].create(
|
|
{
|
|
"name": name,
|
|
"amount": 0,
|
|
"chart_template_id": chart_template.id,
|
|
"tax_group_id": self.env.ref("account.tax_group_taxes").id,
|
|
"refund_repartition_line_ids": [
|
|
(0, 0, {"repartition_type": "base", "factor_percent": 100.0}),
|
|
(0, 0, {"repartition_type": "tax", "factor_percent": 100.0}),
|
|
(0, 0, {"repartition_type": "tax", "factor_percent": 100.0}),
|
|
],
|
|
"invoice_repartition_line_ids": [
|
|
(0, 0, {"repartition_type": "base", "factor_percent": 100.0}),
|
|
(0, 0, {"repartition_type": "tax", "factor_percent": 100.0}),
|
|
(0, 0, {"repartition_type": "tax", "factor_percent": 100.0}),
|
|
],
|
|
}
|
|
)
|
|
self._create_xml_id(record)
|
|
return record
|
|
|
|
def _create_tax_template_with_account(self, name, chart_template, account):
|
|
record = self.env["account.tax.template"].create(
|
|
{
|
|
"name": name,
|
|
"amount": 0,
|
|
"chart_template_id": chart_template.id,
|
|
"tax_group_id": self.env.ref("account.tax_group_taxes").id,
|
|
"refund_repartition_line_ids": [
|
|
(0, 0, {"repartition_type": "base", "factor_percent": 100.0}),
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"repartition_type": "tax",
|
|
"factor_percent": 100.0,
|
|
"account_id": account.id,
|
|
},
|
|
),
|
|
],
|
|
"invoice_repartition_line_ids": [
|
|
(0, 0, {"repartition_type": "base", "factor_percent": 100.0}),
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"repartition_type": "tax",
|
|
"factor_percent": 100.0,
|
|
"account_id": account.id,
|
|
},
|
|
),
|
|
],
|
|
}
|
|
)
|
|
self._create_xml_id(record)
|
|
return record
|
|
|
|
def _create_fp_tmpl(self, name, chart_template):
|
|
record = self.env["account.fiscal.position.template"].create(
|
|
{"name": name, "chart_template_id": chart_template.id}
|
|
)
|
|
self._create_xml_id(record)
|
|
return record
|
|
|
|
def _get_model_data(self, record):
|
|
return self.env["ir.model.data"].search(
|
|
[("model", "=", record._name), ("res_id", "=", record.id)]
|
|
)
|
|
|
|
def setUp(self):
|
|
super(TestAccountChartUpdate, self).setUp()
|
|
self.env.user.lang = "en_US"
|
|
self.env.user.write(
|
|
{
|
|
"groups_id": [
|
|
(6, 0, self.env.user.groups_id.ids),
|
|
(4, self.env.ref("account.group_account_user").id),
|
|
(4, self.env.ref("account.group_account_invoice").id),
|
|
(4, self.env.ref("base.group_multi_company").id),
|
|
]
|
|
}
|
|
)
|
|
self.account_template = self._create_account_tmpl(
|
|
"Test", "100000", "income", False
|
|
)
|
|
self.chart_template = self.env.ref(
|
|
"l10n_generic_coa.configurable_chart_template"
|
|
)
|
|
# Avoid re-creating taxes.
|
|
# If false, the taxes that are created will be overwrited.
|
|
self.account_template.chart_template_id = self.chart_template.id
|
|
self.account_template_pl = self._create_account_tmpl(
|
|
"Undistributed Profits/Losses",
|
|
"999999",
|
|
"equity",
|
|
self.chart_template,
|
|
)
|
|
self.tax_template = self._create_tax_tmpl("Test tax", self.chart_template)
|
|
self.fp_template = self._create_fp_tmpl("Test fp", self.chart_template)
|
|
self.fp_template_tax = self.env["account.fiscal.position.tax.template"].create(
|
|
{"tax_src_id": self.tax_template.id, "position_id": self.fp_template.id}
|
|
)
|
|
self._create_xml_id(self.fp_template_tax)
|
|
self.fp_template_account = self.env[
|
|
"account.fiscal.position.account.template"
|
|
].create(
|
|
{
|
|
"account_src_id": self.account_template.id,
|
|
"account_dest_id": self.account_template.id,
|
|
"position_id": self.fp_template.id,
|
|
}
|
|
)
|
|
self._create_xml_id(self.fp_template_account)
|
|
self.tax_group = self.env["account.tax.group"].create(
|
|
{"name": "Test tax group"}
|
|
)
|
|
self.account_tag_1 = self.env["account.account.tag"].create(
|
|
{"name": "Test account tag 1"}
|
|
)
|
|
self.account_tag_2 = self.env["account.account.tag"].create(
|
|
{"name": "Test account tag 2"}
|
|
)
|
|
self.company = self.env["res.company"].create(
|
|
{
|
|
"name": "Test account_chart_update company",
|
|
"currency_id": self.chart_template.currency_id.id,
|
|
"country_id": self.env.ref("base.es").id,
|
|
}
|
|
)
|
|
self.env.user.write(
|
|
{
|
|
"company_ids": [
|
|
(6, 0, self.env.user.company_ids.ids),
|
|
(4, self.company.id),
|
|
],
|
|
"company_id": self.company.id,
|
|
}
|
|
)
|
|
chart_by_company_user = self.chart_template.with_user(self.env.user)
|
|
chart_by_company_user.try_loading()
|
|
self.tax = self.env["account.tax"].search(
|
|
[
|
|
("name", "=", self.tax_template.name),
|
|
("company_id", "=", self.company.id),
|
|
]
|
|
)
|
|
self.account = self.env["account.account"].search(
|
|
[
|
|
("code", "=", self.account_template.code),
|
|
("company_id", "=", self.company.id),
|
|
]
|
|
)
|
|
self.fp = self.env["account.fiscal.position"].search(
|
|
[("name", "=", self.fp_template.name), ("company_id", "=", self.company.id)]
|
|
)
|
|
# Prepare wizard values
|
|
self.wizard_obj = self.env["wizard.update.charts.accounts"]
|
|
self.wizard_vals = {
|
|
"company_id": self.company.id,
|
|
"chart_template_id": self.chart_template.id,
|
|
"code_digits": 6,
|
|
"lang": "en_US",
|
|
}
|
|
|
|
@mute_logger("odoo.sql_db")
|
|
def test_chart_update(self):
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
# Test ir.model.fields name_get
|
|
field = wizard.fp_field_ids[:1]
|
|
name = field.with_context(account_chart_update=True).name_get()[0]
|
|
self.assertEqual(name[0], field.id)
|
|
self.assertEqual(name[1], "{} ({})".format(field.field_description, field.name))
|
|
name = field.name_get()[0]
|
|
self.assertEqual(name[0], field.id)
|
|
self.assertEqual(
|
|
name[1], "{} ({})".format(field.field_description, field.model)
|
|
)
|
|
# Test no changes
|
|
self.assertEqual(wizard.state, "ready")
|
|
self.assertFalse(wizard.tax_ids)
|
|
self.assertFalse(wizard.account_ids)
|
|
self.assertFalse(wizard.fiscal_position_ids)
|
|
wizard.unlink()
|
|
# Add templates
|
|
new_tax_tmpl = self._create_tax_tmpl("Test tax 2", self.chart_template)
|
|
new_tax_tmpl.refund_repartition_line_ids[2].write(
|
|
{"tag_ids": [(6, 0, self.account_tag_1.ids)]}
|
|
)
|
|
new_tax_tmpl.invoice_repartition_line_ids[2].write(
|
|
{"tag_ids": [(6, 0, self.account_tag_1.ids)]}
|
|
)
|
|
new_account_tmpl = self._create_account_tmpl(
|
|
"Test account 2", "333333", "income", self.chart_template
|
|
)
|
|
new_fp = self._create_fp_tmpl("Test fp 2", self.chart_template)
|
|
fp_template_tax = self.env["account.fiscal.position.tax.template"].create(
|
|
{"tax_src_id": self.tax_template.id, "position_id": new_fp.id}
|
|
)
|
|
self._create_xml_id(fp_template_tax)
|
|
fp_template_account = self.env[
|
|
"account.fiscal.position.account.template"
|
|
].create(
|
|
{
|
|
"account_src_id": self.account_template.id,
|
|
"account_dest_id": self.account_template.id,
|
|
"position_id": new_fp.id,
|
|
}
|
|
)
|
|
self._create_xml_id(fp_template_account)
|
|
# Tax with account in repartition lines
|
|
tax_template_with_account = self._create_tax_template_with_account(
|
|
"Test tax with account", self.chart_template, new_account_tmpl
|
|
)
|
|
# Check that no action is performed if the option is not selected
|
|
wizard_vals = self.wizard_vals.copy()
|
|
wizard_vals.update(
|
|
{
|
|
"update_tax": False,
|
|
"update_account": False,
|
|
"update_fiscal_position": False,
|
|
"update_tax_repartition_line_account": False,
|
|
"update_tax_repartition_line_tags": False,
|
|
}
|
|
)
|
|
wizard = self.wizard_obj.create(wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertFalse(wizard.tax_ids)
|
|
self.assertFalse(wizard.account_ids)
|
|
self.assertFalse(wizard.fiscal_position_ids)
|
|
wizard.unlink()
|
|
# Now do the real one for detecting additions
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertTrue(wizard.tax_ids)
|
|
self.assertEqual(
|
|
wizard.tax_ids.tax_id, new_tax_tmpl + tax_template_with_account
|
|
)
|
|
for tax in wizard.tax_ids:
|
|
self.assertEqual(tax.type, "new")
|
|
self.assertTrue(wizard.account_ids)
|
|
self.assertEqual(wizard.account_ids.account_id, new_account_tmpl)
|
|
self.assertTrue(wizard.fiscal_position_ids)
|
|
self.assertEqual(wizard.fiscal_position_ids.fiscal_position_id, new_fp)
|
|
self.assertEqual(wizard.fiscal_position_ids.type, "new")
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.state, "done")
|
|
self.assertEqual(wizard.new_taxes, 2)
|
|
self.assertEqual(wizard.new_accounts, 1)
|
|
self.assertEqual(wizard.new_fps, 1)
|
|
self.assertTrue(wizard.log)
|
|
new_tax = self.env["account.tax"].search(
|
|
[("name", "=", new_tax_tmpl.name), ("company_id", "=", self.company.id)]
|
|
)
|
|
self.assertTrue(new_tax)
|
|
tax_with_account = self.env["account.tax"].search(
|
|
[
|
|
("name", "=", "Test tax with account"),
|
|
("company_id", "=", self.company.id),
|
|
]
|
|
)
|
|
self.assertTrue(tax_with_account)
|
|
new_account = self.env["account.account"].search(
|
|
[("code", "=", new_account_tmpl.code), ("company_id", "=", self.company.id)]
|
|
)
|
|
self.assertTrue(new_account)
|
|
fp = self.env["account.fiscal.position"].search(
|
|
[("name", "=", new_fp.name), ("company_id", "=", self.company.id)]
|
|
)
|
|
self.assertTrue(fp)
|
|
self.assertTrue(fp.tax_ids)
|
|
self.assertTrue(fp.account_ids)
|
|
wizard.unlink()
|
|
# Update objects
|
|
self.tax_template.description = "Test description"
|
|
self.tax_template.tax_group_id = self.tax_group.id
|
|
repartition = self.tax_template.refund_repartition_line_ids.filtered(
|
|
lambda r: r.repartition_type == "tax"
|
|
)[0]
|
|
repartition.account_id = new_account_tmpl.id
|
|
self.account_template.name = "Other name"
|
|
self.account_template.tag_ids = [
|
|
(6, 0, [self.account_tag_1.id, self.account_tag_2.id])
|
|
]
|
|
self.fp_template.note = "Test note. \n \n Multiline. \n"
|
|
self.fp_template.account_ids.account_dest_id = new_account_tmpl.id
|
|
self.fp_template.tax_ids.tax_dest_id = self.tax_template.id
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertTrue(wizard.tax_ids)
|
|
self.assertEqual(
|
|
wizard.tax_ids.tax_id.ids, [self.tax_template.id, new_tax_tmpl.id]
|
|
)
|
|
self.assertEqual(list(set(wizard.tax_ids.mapped("type")))[0], "updated")
|
|
self.assertTrue(wizard.account_ids)
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
self.assertTrue(wizard.fiscal_position_ids)
|
|
self.assertEqual(wizard.fiscal_position_ids.type, "updated")
|
|
self.assertEqual(
|
|
wizard.fiscal_position_ids.fiscal_position_id, self.fp_template
|
|
)
|
|
self.assertEqual(wizard.fiscal_position_ids.type, "updated")
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_taxes, 2)
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(wizard.updated_fps, 1)
|
|
self.assertEqual(self.tax.description, self.tax_template.description)
|
|
self.assertEqual(self.tax.tax_group_id, self.tax_group)
|
|
repartition = self.tax.refund_repartition_line_ids.filtered(
|
|
lambda r: r.repartition_type == "tax"
|
|
)
|
|
self.assertEqual(repartition.account_id, new_account)
|
|
self.assertEqual(self.account.name, self.account_template.name)
|
|
self.assertIn(self.account_tag_1, self.account.tag_ids)
|
|
self.assertIn(self.account_tag_2, self.account.tag_ids)
|
|
self.assertEqual(self.fp.note, f"<p>{self.fp_template.note}</p>")
|
|
self.assertEqual(self.fp.account_ids.account_dest_id, new_account)
|
|
self.assertEqual(self.fp.tax_ids.tax_dest_id, self.tax)
|
|
wizard.unlink()
|
|
# Exclude fields from check
|
|
self.tax_template.description = "Test description 2"
|
|
self.account_template.name = "Other name 2"
|
|
self.fp_template.note = "Test note 2"
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
wizard.tax_field_ids -= self.env["ir.model.fields"].search(
|
|
[("model", "=", "account.tax.template"), ("name", "=", "description")]
|
|
)
|
|
wizard.account_field_ids -= self.env["ir.model.fields"].search(
|
|
[("model", "=", "account.account.template"), ("name", "=", "name")]
|
|
)
|
|
wizard.fp_field_ids -= self.env["ir.model.fields"].search(
|
|
[("model", "=", "account.fiscal.position.template"), ("name", "=", "note")]
|
|
)
|
|
wizard.action_find_records()
|
|
self.assertTrue(wizard.tax_ids)
|
|
self.assertFalse(wizard.account_ids)
|
|
self.assertFalse(wizard.fiscal_position_ids)
|
|
self.tax_template.description = "Test description"
|
|
self.account_template.name = "Other name"
|
|
wizard.unlink()
|
|
# Remove objects
|
|
new_tax_tmpl.unlink()
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertTrue(wizard.tax_ids)
|
|
self.assertEqual(wizard.tax_ids.update_tax_id, new_tax)
|
|
self.assertEqual(wizard.tax_ids.type, "deleted")
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.deleted_taxes, 1)
|
|
self.assertFalse(new_tax.active)
|
|
wizard.unlink()
|
|
# Errors on account update
|
|
self.account_template.currency_id = self.ref("base.USD")
|
|
self.env["account.move"].create(
|
|
{
|
|
"name": "Test move",
|
|
"move_type": "entry",
|
|
"journal_id": self.env["account.journal"]
|
|
.search([("company_id", "=", self.company.id)], limit=1)
|
|
.id,
|
|
"date": fields.Date.today(),
|
|
"line_ids": [
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"account_id": self.account.id,
|
|
"name": "Test move line",
|
|
"debit": 10,
|
|
"credit": 0,
|
|
"amount_currency": 8,
|
|
"currency_id": self.ref("base.GBP"),
|
|
},
|
|
),
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"account_id": self.account.id,
|
|
"name": "Test move line2",
|
|
"debit": 0,
|
|
"credit": 10,
|
|
"amount_currency": -8,
|
|
"currency_id": self.ref("base.GBP"),
|
|
},
|
|
),
|
|
],
|
|
}
|
|
)
|
|
self.tax_template.description = "Other description"
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
with self.assertRaises(Exception): # noqa: B017
|
|
wizard.action_update_records()
|
|
# Errors on account update - continuing after that
|
|
wizard.continue_on_errors = True
|
|
wizard.action_update_records()
|
|
self.assertFalse(self.account.currency_id)
|
|
self.assertEqual(self.tax.description, self.tax_template.description)
|
|
self.assertEqual(wizard.rejected_updated_account_number, 1)
|
|
self.assertEqual(wizard.updated_accounts, 0)
|
|
wizard.unlink()
|
|
# Errors on account_creation
|
|
self.account_template.currency_id = False
|
|
new_account_tmpl_2 = self._create_account_tmpl(
|
|
"Test account 3", "444444", "income", self.chart_template
|
|
)
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.account_ids.type, "new")
|
|
new_account_tmpl_2.code = "333333" # Trick the code for forcing error
|
|
with self.assertRaises(Exception): # noqa: B017
|
|
wizard.action_update_records()
|
|
wizard.continue_on_errors = True
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.rejected_new_account_number, 1)
|
|
self.assertEqual(wizard.new_accounts, 0)
|
|
wizard.unlink()
|
|
|
|
def test_chart_update_groups(self):
|
|
self.wizard_vals.update(
|
|
{
|
|
"update_account": False,
|
|
"update_tax": False,
|
|
"update_fiscal_position": False,
|
|
"recreate_xml_ids": True,
|
|
}
|
|
)
|
|
template_1 = self.env["account.group.template"].create(
|
|
{
|
|
"name": "TEST",
|
|
"code_prefix_start": "TESTZ",
|
|
"chart_template_id": self.chart_template.id,
|
|
}
|
|
)
|
|
self._create_xml_id(template_1)
|
|
template_2 = self.env["account.group.template"].create(
|
|
{
|
|
"name": "TEST",
|
|
"code_prefix_start": "TESTY",
|
|
"chart_template_id": self.chart_template.id,
|
|
}
|
|
)
|
|
self._create_xml_id(template_2)
|
|
group_1 = self.env["account.group"].create(
|
|
{
|
|
"name": "TEST",
|
|
"code_prefix_start": "TESTZ",
|
|
"code_prefix_end": "TESZZ",
|
|
"company_id": self.company.id,
|
|
}
|
|
)
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(2, len(wizard.account_group_ids))
|
|
self.assertEqual(
|
|
template_1,
|
|
wizard.account_group_ids.filtered(
|
|
lambda r: r.type == "updated"
|
|
).account_group_id,
|
|
)
|
|
self.assertEqual(
|
|
group_1,
|
|
wizard.account_group_ids.filtered(
|
|
lambda r: r.type == "updated"
|
|
).update_account_group_id,
|
|
)
|
|
self.assertEqual(
|
|
template_2,
|
|
wizard.account_group_ids.filtered(
|
|
lambda r: r.type == "new"
|
|
).account_group_id,
|
|
)
|
|
wizard.action_update_records()
|
|
self.assertEqual(1, wizard.updated_account_groups)
|
|
self.assertEqual(1, wizard.new_account_groups)
|
|
self.assertEqual("TESTZ", group_1.code_prefix_end)
|
|
self.assertTrue(list(group_1.get_xml_id().values())[0])
|
|
|
|
def test_matching(self):
|
|
# Test XML-ID matching
|
|
self.tax_template.name = "Test 1 tax name changed"
|
|
self.tax_template.description = "Test tax 1 description changed"
|
|
self.account_template.code = "200000"
|
|
self.fp_template.name = "Test 1 fp name changed"
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.tax_ids.tax_id, self.tax_template)
|
|
self.assertEqual(wizard.tax_ids.type, "updated")
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
self.assertTrue(wizard.fiscal_position_ids.type, "updated")
|
|
self.assertEqual(
|
|
wizard.fiscal_position_ids.fiscal_position_id, self.fp_template
|
|
)
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_taxes, 1)
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(wizard.updated_fps, 1)
|
|
self.assertEqual(self.tax.name, self.tax_template.name)
|
|
self.assertEqual(self.tax.description, self.tax_template.description)
|
|
self.assertEqual(self.account.code, self.account_template.code)
|
|
self.assertEqual(self.fp.name, self.fp_template.name)
|
|
wizard.unlink()
|
|
|
|
# Test match by another field, there is no match by XML-ID
|
|
self._get_model_data(self.tax).unlink()
|
|
self._get_model_data(self.account).unlink()
|
|
self._get_model_data(self.fp).unlink()
|
|
self.tax_template.description = "Test 2 tax description changed"
|
|
self.account_template.name = "Test 2 account name changed"
|
|
self.fp_template.note = "<p>Test 2 fp note changed</p>"
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.tax_ids.tax_id, self.tax_template)
|
|
self.assertEqual(wizard.tax_ids.type, "updated")
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
self.assertTrue(wizard.fiscal_position_ids.type, "updated")
|
|
self.assertEqual(
|
|
wizard.fiscal_position_ids.fiscal_position_id, self.fp_template
|
|
)
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_taxes, 1)
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(wizard.updated_fps, 1)
|
|
self.assertEqual(self.tax.description, self.tax_template.description)
|
|
self.assertEqual(self.account.name, self.account_template.name)
|
|
self.assertEqual(self.fp.note, self.fp_template.note)
|
|
wizard.unlink()
|
|
|
|
# Test match by name, there is no match by XML-ID or by code
|
|
self.account_template.code = "300000"
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(self.account.code, self.account_template.code)
|
|
wizard.unlink()
|
|
|
|
# Test 1 recreate XML-ID
|
|
self.tax_template.description = "Test 4 tax description changed"
|
|
self.account_template.name = "Test 4 account name changed"
|
|
self.fp_template.note = "<p>Test 4 fp note changed</p>"
|
|
self.wizard_vals.update(recreate_xml_ids=True)
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.tax_ids.tax_id, self.tax_template)
|
|
self.assertEqual(wizard.tax_ids.type, "updated")
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
self.assertTrue(wizard.fiscal_position_ids.type, "updated")
|
|
self.assertEqual(
|
|
wizard.fiscal_position_ids.fiscal_position_id, self.fp_template
|
|
)
|
|
# There is no XML-ID
|
|
self.assertFalse(list(self.tax.get_external_id().values())[0])
|
|
self.assertFalse(list(self.account.get_external_id().values())[0])
|
|
self.assertFalse(list(self.fp.get_external_id().values())[0])
|
|
# Update for recreating XML-ID
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_taxes, 1)
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(wizard.updated_fps, 1)
|
|
self.assertEqual(self.tax.description, self.tax_template.description)
|
|
self.assertEqual(self.account.name, self.account_template.name)
|
|
self.assertEqual(self.fp.note, self.fp_template.note)
|
|
# There is XML-ID now
|
|
self.assertTrue(list(self.tax.get_external_id().values())[0])
|
|
self.assertTrue(list(self.account.get_external_id().values())[0])
|
|
self.assertTrue(list(self.fp.get_external_id().values())[0])
|
|
wizard.unlink()
|
|
|
|
# Test 2 recreate XML-ID
|
|
self._get_model_data(self.tax).unlink()
|
|
self._get_model_data(self.account).unlink()
|
|
self._get_model_data(self.fp).unlink()
|
|
wizard = self.wizard_obj.create(self.wizard_vals)
|
|
wizard.action_find_records()
|
|
self.assertEqual(wizard.tax_ids.tax_id, self.tax_template)
|
|
self.assertEqual(wizard.tax_ids.type, "updated")
|
|
self.assertEqual(wizard.account_ids.account_id, self.account_template)
|
|
self.assertEqual(wizard.account_ids.type, "updated")
|
|
self.assertTrue(wizard.fiscal_position_ids.type, "updated")
|
|
self.assertEqual(
|
|
wizard.fiscal_position_ids.fiscal_position_id, self.fp_template
|
|
)
|
|
# There is no XML-ID
|
|
self.assertFalse(list(self.tax.get_external_id().values())[0])
|
|
self.assertFalse(list(self.account.get_external_id().values())[0])
|
|
self.assertFalse(list(self.fp.get_external_id().values())[0])
|
|
# Update for recreating XML-ID
|
|
wizard.action_update_records()
|
|
self.assertEqual(wizard.updated_taxes, 1)
|
|
self.assertEqual(wizard.updated_accounts, 1)
|
|
self.assertEqual(wizard.updated_fps, 1)
|
|
# There is XML-ID now
|
|
self.assertTrue(list(self.tax.get_external_id().values())[0])
|
|
self.assertTrue(list(self.account.get_external_id().values())[0])
|
|
self.assertTrue(list(self.fp.get_external_id().values())[0])
|
|
wizard.unlink()
|