Initial commit: Odoo 18.0-20251222 extra-addons

account_spread_cost_revenue/tests/__init__.py

@@ -0,0 +1,6 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from . import test_account_spread_cost_revenue
+from . import test_compute_spread_board
+from . import test_account_invoice_spread
+from . import test_account_invoice_auto_spread

account_spread_cost_revenue/tests/test_account_invoice_auto_spread.py

@@ -0,0 +1,102 @@
+# Copyright 2018-2019 Onestein (<https://www.onestein.eu>)
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo.exceptions import UserError
+from odoo.tests import tagged
+
+from .test_account_invoice_spread import TestAccountInvoiceSpread
+
+
+@tagged("post_install", "-at_install")
+class TestAccountInvoiceAutoSpread(TestAccountInvoiceSpread):
+    def test_01_no_auto_spread_sheet(self):
+        self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "purchase",
+                "period_number": 5,
+                "period_type": "month",
+                "spread_account_id": self.account_payable.id,
+                "spread_journal_id": self.expenses_journal.id,
+                "auto_spread": False,  # Auto Spread = False
+                "auto_spread_ids": [
+                    (0, 0, {"account_id": self.vendor_bill_line.account_id.id})
+                ],
+            }
+        )
+
+        self.assertFalse(self.vendor_bill_line.spread_id)
+        self.vendor_bill.action_post()
+        self.assertFalse(self.vendor_bill_line.spread_id)
+
+    def test_02_new_auto_spread_sheet_purchase(self):
+        self.env["account.spread.template"].create(
+            {
+                "name": "test 1",
+                "spread_type": "purchase",
+                "period_number": 5,
+                "period_type": "month",
+                "spread_account_id": self.account_payable.id,
+                "spread_journal_id": self.expenses_journal.id,
+                "auto_spread": True,  # Auto Spread
+                "auto_spread_ids": [
+                    (0, 0, {"account_id": self.vendor_bill_line.account_id.id})
+                ],
+            }
+        )
+        template2 = self.env["account.spread.template"].create(
+            {
+                "name": "test 2",
+                "spread_type": "purchase",
+                "period_number": 5,
+                "period_type": "month",
+                "spread_account_id": self.account_payable.id,
+                "spread_journal_id": self.expenses_journal.id,
+                "auto_spread": True,  # Auto Spread
+                "auto_spread_ids": [
+                    (0, 0, {"account_id": self.vendor_bill_line.account_id.id})
+                ],
+            }
+        )
+
+        self.assertFalse(self.vendor_bill_line.spread_id)
+        with self.assertRaises(UserError):  # too many auto_spread_ids matched
+            self.vendor_bill.action_post()
+
+        template2.auto_spread = False  # Do not use this template
+        self.vendor_bill.action_post()
+        self.assertTrue(self.vendor_bill_line.spread_id)
+
+        spread_lines = self.vendor_bill_line.spread_id.line_ids
+        self.assertTrue(spread_lines)
+
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+    def test_03_new_auto_spread_sheet_sale(self):
+        self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "sale",
+                "period_number": 5,
+                "period_type": "month",
+                "spread_account_id": self.account_receivable.id,
+                "spread_journal_id": self.sales_journal.id,
+                "auto_spread": True,  # Auto Spread
+                "auto_spread_ids": [
+                    (0, 0, {"account_id": self.invoice_line.account_id.id})
+                ],
+            }
+        )
+
+        self.assertFalse(self.invoice_line.spread_id)
+        self.sale_invoice.action_post()
+        self.assertTrue(self.invoice_line.spread_id)
+
+        spread_lines = self.invoice_line.spread_id.line_ids
+        self.assertTrue(spread_lines)
+
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)

account_spread_cost_revenue/tests/test_account_invoice_spread.py

@@ -0,0 +1,799 @@
+# Copyright 2018-2020 Onestein (<https://www.onestein.eu>)
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import datetime
+
+from odoo import fields
+from odoo.exceptions import UserError, ValidationError
+from odoo.tests import Form, common, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestAccountInvoiceSpread(common.TransactionCase):
+    @classmethod
+    def create_account_invoice(self, invoice_type, quantity=1.0, price_unit=1000.0):
+        """Create an invoice as in a view by triggering its onchange methods"""
+
+        invoice_form = Form(
+            self.env["account.move"].with_context(default_move_type=invoice_type)
+        )
+        invoice_form.partner_id = self.env["res.partner"].create(
+            {"name": "Partner Name"}
+        )
+        with invoice_form.invoice_line_ids.new() as line:
+            line.name = "product that costs " + str(price_unit)
+            line.quantity = quantity
+            line.price_unit = price_unit
+
+        return invoice_form.save()
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        # Define minimal accounting data to run
+        a_expense = cls.env["account.account"].create(
+            {
+                "code": "X2120",
+                "name": "Expenses - (test)",
+                "account_type": "expense",
+            }
+        )
+        a_sale = cls.env["account.account"].create(
+            {
+                "code": "X2020",
+                "name": "Product Sales - (test)",
+                "account_type": "expense_direct_cost",
+            }
+        )
+
+        cls.expenses_journal = cls.env["account.journal"].create(
+            {
+                "name": "Vendor Bills - Test",
+                "code": "TEXJ",
+                "type": "purchase",
+                "default_account_id": a_expense.id,
+                "refund_sequence": True,
+            }
+        )
+        cls.sales_journal = cls.env["account.journal"].create(
+            {
+                "name": "Customer Invoices - Test",
+                "code": "TINV",
+                "type": "sale",
+                "default_account_id": a_sale.id,
+                "refund_sequence": True,
+            }
+        )
+
+        cls.account_payable = cls.env["account.account"].create(
+            {
+                "name": "Test account payable",
+                "code": "321spread",
+                "account_type": "income_other",
+                "reconcile": True,
+            }
+        )
+
+        cls.account_receivable = cls.env["account.account"].create(
+            {
+                "name": "Test account receivable",
+                "code": "322spread",
+                "account_type": "income_other",
+                "reconcile": True,
+            }
+        )
+
+        spread_account_payable = cls.env["account.account"].create(
+            {
+                "name": "test spread account_payable",
+                "code": "765spread",
+                "account_type": "income_other",
+                "reconcile": True,
+            }
+        )
+
+        spread_account_receivable = cls.env["account.account"].create(
+            {
+                "name": "test spread account_receivable",
+                "code": "766spread",
+                "account_type": "income_other",
+                "reconcile": True,
+            }
+        )
+
+        # Invoices
+
+        cls.vendor_bill = cls.create_account_invoice(invoice_type="in_invoice")
+        cls.vendor_bill.invoice_date = fields.Date.today()
+        cls.sale_invoice = cls.create_account_invoice(invoice_type="out_invoice")
+        cls.sale_invoice.invoice_date = fields.Date.today()
+        cls.vendor_bill_line = cls.vendor_bill.invoice_line_ids[0]
+        cls.invoice_line = cls.sale_invoice.invoice_line_ids[0]
+
+        # Set accounts to reconcilable
+        cls.vendor_bill_line.account_id.reconcile = True
+        cls.invoice_line.account_id.reconcile = True
+
+        analytic_plan = cls.env["account.analytic.plan"].create({"name": "Plan Test"})
+        cls.analytic_account = cls.env["account.analytic.account"].create(
+            {"name": "test account", "plan_id": analytic_plan.id}
+        )
+        cls.distribution = cls.env["account.analytic.distribution.model"].create(
+            {
+                "partner_id": cls.vendor_bill.partner_id.id,
+                "analytic_distribution": {cls.analytic_account.id: 100},
+            }
+        )
+        cls.spread = (
+            cls.env["account.spread"]
+            .with_context(mail_create_nosubscribe=True)
+            .create(
+                [
+                    {
+                        "name": "test",
+                        "debit_account_id": spread_account_payable.id,
+                        "credit_account_id": cls.account_payable.id,
+                        "period_number": 12,
+                        "period_type": "month",
+                        "spread_date": datetime.date(2017, 2, 1),
+                        "estimated_amount": 1000.0,
+                        "journal_id": cls.vendor_bill.journal_id.id,
+                        "invoice_type": "in_invoice",
+                        "analytic_distribution": cls.distribution._get_distribution(
+                            {
+                                "partner_id": cls.vendor_bill.partner_id.id,
+                            }
+                        ),
+                    }
+                ]
+            )
+        )
+
+        cls.spread2 = cls.env["account.spread"].create(
+            [
+                {
+                    "name": "test2",
+                    "debit_account_id": spread_account_receivable.id,
+                    "credit_account_id": cls.account_receivable.id,
+                    "period_number": 12,
+                    "period_type": "month",
+                    "spread_date": datetime.date(2017, 2, 1),
+                    "estimated_amount": 1000.0,
+                    "journal_id": cls.sale_invoice.journal_id.id,
+                    "invoice_type": "out_invoice",
+                }
+            ]
+        )
+
+    def test_01_wizard_defaults(self):
+        Wizard = self.env["account.spread.invoice.line.link.wizard"]
+
+        wizard1 = Wizard.with_context(
+            default_invoice_line_id=self.vendor_bill_line.id,
+            default_company_id=self.env.company.id,
+            allow_spread_planning=True,
+        ).create({})
+        self.assertEqual(wizard1.invoice_line_id, self.vendor_bill_line)
+        self.assertEqual(wizard1.invoice_line_id.move_id, self.vendor_bill)
+        self.assertEqual(wizard1.invoice_type, "in_invoice")
+        self.assertFalse(wizard1.spread_id)
+        self.assertEqual(wizard1.company_id, self.env.company)
+        self.assertEqual(wizard1.spread_action_type, "link")
+        self.assertFalse(wizard1.spread_account_id)
+        self.assertFalse(wizard1.spread_journal_id)
+
+        wizard2 = Wizard.with_context(
+            default_invoice_line_id=self.invoice_line.id,
+            default_company_id=self.env.company.id,
+        ).create({})
+
+        self.assertEqual(wizard2.invoice_line_id, self.invoice_line)
+        self.assertEqual(wizard2.invoice_line_id.move_id, self.sale_invoice)
+        self.assertEqual(wizard2.invoice_type, "out_invoice")
+        self.assertFalse(wizard2.spread_id)
+        self.assertEqual(wizard2.company_id, self.env.company)
+        self.assertEqual(wizard2.spread_action_type, "template")
+        self.assertFalse(wizard2.spread_account_id)
+        self.assertFalse(wizard2.spread_journal_id)
+
+    def test_02_wizard_defaults(self):
+        Wizard = self.env["account.spread.invoice.line.link.wizard"]
+
+        self.env.company.default_spread_revenue_account_id = self.account_receivable
+        self.env.company.default_spread_expense_account_id = self.account_payable
+        self.env.company.default_spread_revenue_journal_id = self.sales_journal
+        self.env.company.default_spread_expense_journal_id = self.expenses_journal
+
+        self.assertTrue(self.env.company.default_spread_revenue_account_id)
+        self.assertTrue(self.env.company.default_spread_expense_account_id)
+        self.assertTrue(self.env.company.default_spread_revenue_journal_id)
+        self.assertTrue(self.env.company.default_spread_expense_journal_id)
+
+        wizard1 = Wizard.with_context(
+            default_invoice_line_id=self.vendor_bill_line.id,
+            default_company_id=self.env.company.id,
+            allow_spread_planning=True,
+        ).create({})
+
+        self.assertEqual(wizard1.invoice_line_id, self.vendor_bill_line)
+        self.assertEqual(wizard1.invoice_line_id.move_id, self.vendor_bill)
+        self.assertEqual(wizard1.invoice_type, "in_invoice")
+        self.assertFalse(wizard1.spread_id)
+        self.assertEqual(wizard1.company_id, self.env.company)
+        self.assertEqual(wizard1.spread_action_type, "link")
+        self.assertTrue(wizard1.spread_account_id)
+        self.assertTrue(wizard1.spread_journal_id)
+        self.assertEqual(wizard1.spread_account_id, self.account_payable)
+        self.assertEqual(wizard1.spread_journal_id.id, self.expenses_journal.id)
+        self.assertTrue(wizard1.spread_invoice_type_domain_ids)
+
+        wizard2 = Wizard.with_context(
+            default_invoice_line_id=self.invoice_line.id,
+            default_company_id=self.env.company.id,
+        ).create({})
+
+        self.assertEqual(wizard2.invoice_line_id, self.invoice_line)
+        self.assertEqual(wizard2.invoice_line_id.move_id, self.sale_invoice)
+        self.assertEqual(wizard2.invoice_type, "out_invoice")
+        self.assertFalse(wizard2.spread_id)
+        self.assertEqual(wizard2.company_id, self.env.company)
+        self.assertEqual(wizard2.spread_action_type, "template")
+        self.assertTrue(wizard2.spread_account_id)
+        self.assertTrue(wizard2.spread_journal_id)
+        self.assertEqual(wizard2.spread_account_id, self.account_receivable)
+        self.assertEqual(wizard2.spread_journal_id.id, self.sales_journal.id)
+        self.assertTrue(wizard2.spread_invoice_type_domain_ids)
+
+    def test_03_link_invoice_line_with_spread_sheet(self):
+        self.env.user.write(
+            {
+                "groups_id": [
+                    (4, self.env.ref("analytic.group_analytic_accounting").id),
+                ],
+            }
+        )
+
+        Wizard = self.env["account.spread.invoice.line.link.wizard"]
+        wizard1 = Wizard.with_context(
+            default_invoice_line_id=self.vendor_bill_line.id,
+            default_company_id=self.env.company.id,
+            allow_spread_planning=True,
+        ).create({})
+        self.assertEqual(wizard1.spread_action_type, "link")
+
+        wizard1.spread_account_id = self.account_receivable
+        wizard1.spread_journal_id = self.expenses_journal
+        wizard1.spread_id = self.spread
+        res_action = wizard1.confirm()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertTrue(res_action.get("res_id"))
+        self.assertEqual(res_action.get("res_id"), self.spread.id)
+        self.assertTrue(self.spread.invoice_line_id)
+        self.assertEqual(self.spread.invoice_line_id, self.vendor_bill_line)
+
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+            for ml in line.move_id.line_ids:
+                self.assertEqual(
+                    ml.analytic_distribution, self.spread.analytic_distribution
+                )
+
+        self.spread.invoice_id.button_cancel()
+
+        self.assertTrue(self.spread.invoice_line_id)
+        with self.assertRaises(UserError):
+            self.spread.unlink()
+        with self.assertRaises(UserError):
+            self.spread.action_unlink_invoice_line()
+        self.assertTrue(self.spread.invoice_line_id)
+
+    def test_04_new_spread_sheet(self):
+        Wizard = self.env["account.spread.invoice.line.link.wizard"]
+
+        spread_journal_id = self.expenses_journal
+
+        wizard1 = Wizard.with_context(
+            default_invoice_line_id=self.vendor_bill_line.id,
+            default_company_id=self.env.company.id,
+        ).create({"spread_action_type": "new"})
+        self.assertEqual(wizard1.spread_action_type, "new")
+
+        wizard1.write(
+            {
+                "spread_account_id": self.account_receivable.id,
+                "spread_journal_id": spread_journal_id,
+            }
+        )
+
+        res_action = wizard1.confirm()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertFalse(res_action.get("res_id"))
+        self.assertTrue(res_action.get("context"))
+        res_context = res_action.get("context")
+        self.assertTrue(res_context.get("default_name"))
+        self.assertTrue(res_context.get("default_invoice_type"))
+        self.assertTrue(res_context.get("default_invoice_line_id"))
+        self.assertTrue(res_context.get("default_debit_account_id"))
+        self.assertTrue(res_context.get("default_credit_account_id"))
+
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        wizard2 = Wizard.with_context(
+            default_invoice_line_id=self.invoice_line.id,
+            default_company_id=self.env.company.id,
+        ).create({"spread_action_type": "new"})
+        self.assertEqual(wizard2.spread_action_type, "new")
+
+        wizard2.write(
+            {
+                "spread_account_id": self.account_receivable.id,
+                "spread_journal_id": spread_journal_id,
+            }
+        )
+
+        res_action = wizard2.confirm()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertFalse(res_action.get("res_id"))
+        self.assertTrue(res_action.get("context"))
+        res_context = res_action.get("context")
+        self.assertTrue(res_context.get("default_name"))
+        self.assertTrue(res_context.get("default_invoice_type"))
+        self.assertTrue(res_context.get("default_invoice_line_id"))
+        self.assertTrue(res_context.get("default_debit_account_id"))
+        self.assertTrue(res_context.get("default_credit_account_id"))
+
+        self.assertFalse(any(line.move_id for line in self.spread2.line_ids))
+
+        self.spread2.compute_spread_board()
+        for line in self.spread2.line_ids:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+    def test_05_new_spread_sheet_from_template(self):
+        Wizard = self.env["account.spread.invoice.line.link.wizard"]
+
+        spread_account = self.account_payable
+        self.assertTrue(spread_account)
+        spread_journal_id = self.expenses_journal.id
+
+        template = self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "purchase",
+                "period_number": 5,
+                "period_type": "month",
+                "spread_account_id": spread_account.id,
+                "spread_journal_id": spread_journal_id,
+            }
+        )
+
+        wizard1 = Wizard.with_context(
+            default_invoice_line_id=self.vendor_bill_line.id,
+            default_company_id=self.env.company.id,
+        ).create({"spread_action_type": "template", "template_id": template.id})
+        self.assertEqual(wizard1.spread_action_type, "template")
+
+        res_action = wizard1.confirm()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertTrue(res_action.get("res_id"))
+
+        new_spread = self.env["account.spread"].browse(res_action["res_id"])
+        new_spread.compute_spread_board()
+
+        self.assertFalse(any(line.move_id for line in new_spread.line_ids))
+
+        for line in new_spread.line_ids:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        wizard2 = Wizard.with_context(
+            default_invoice_line_id=self.invoice_line.id,
+            default_company_id=self.env.company.id,
+        ).create({"spread_action_type": "new"})
+        self.assertEqual(wizard2.spread_action_type, "new")
+
+        wizard2.write(
+            {
+                "spread_account_id": spread_account.id,
+                "spread_journal_id": spread_journal_id,
+            }
+        )
+
+        res_action = wizard2.confirm()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertFalse(res_action.get("res_id"))
+        self.assertTrue(res_action.get("context"))
+        res_context = res_action.get("context")
+        self.assertTrue(res_context.get("default_name"))
+        self.assertTrue(res_context.get("default_invoice_type"))
+        self.assertTrue(res_context.get("default_invoice_line_id"))
+        self.assertTrue(res_context.get("default_debit_account_id"))
+        self.assertTrue(res_context.get("default_credit_account_id"))
+
+        self.assertFalse(any(line.move_id for line in self.spread2.line_ids))
+
+        self.spread2.compute_spread_board()
+        for line in self.spread2.line_ids:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+    def test_06_open_wizard(self):
+        res_action = self.vendor_bill_line.spread_details()
+        self.assertTrue(isinstance(res_action, dict))
+        self.assertFalse(res_action.get("res_id"))
+        self.assertTrue(res_action.get("context"))
+
+    def test_07_unlink_invoice_line_and_spread_sheet(self):
+        self.assertFalse(self.spread.invoice_line_id)
+
+        self.vendor_bill_line.spread_id = self.spread
+        self.assertTrue(self.spread.invoice_line_id)
+        self.spread.action_unlink_invoice_line()
+        self.assertFalse(self.spread.invoice_line_id)
+
+        self.assertFalse(self.spread2.invoice_line_id)
+        self.invoice_line.spread_id = self.spread2
+        self.assertTrue(self.spread2.invoice_line_id)
+        self.spread2.action_unlink_invoice_line()
+        self.assertFalse(self.spread2.invoice_line_id)
+
+    def test_08_invoice_multi_line(self):
+        invoice_form = Form(self.vendor_bill)
+        with invoice_form.invoice_line_ids.new() as line:
+            line.name = "new test line"
+            line.quantity = 1.0
+            line.price_unit = 1000.0
+        self.invoice = invoice_form.save()
+        self.assertEqual(len(self.vendor_bill.invoice_line_ids), 2)
+
+        self.vendor_bill_line.spread_id = self.spread
+        self.assertTrue(self.spread.invoice_id.invoice_line_ids[0])
+        self.assertEqual(
+            self.spread.invoice_id.invoice_line_ids[0], self.vendor_bill_line
+        )
+        self.assertTrue(self.vendor_bill_line.spread_id)
+        self.assertEqual(self.vendor_bill_line.spread_check, "linked")
+        self.assertFalse(self.vendor_bill.invoice_line_ids[1].spread_id)
+        self.assertEqual(self.vendor_bill.invoice_line_ids[1].spread_check, "unlinked")
+
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        # Validate invoice
+        self.vendor_bill.action_post()
+
+        self.assertTrue(self.vendor_bill_line.spread_id)
+        self.assertEqual(self.vendor_bill_line.spread_check, "linked")
+        self.assertFalse(self.vendor_bill.invoice_line_ids[1].spread_id)
+        self.assertEqual(
+            self.vendor_bill.invoice_line_ids[1].spread_check, "unavailable"
+        )
+
+    def test_09_no_link_invoice(self):
+        balance_sheet = self.spread.credit_account_id
+
+        # Validate invoice
+        self.vendor_bill.action_post()
+
+        invoice_mls = self.vendor_bill.invoice_line_ids
+        self.assertTrue(invoice_mls)
+        for invoice_ml in invoice_mls:
+            self.assertNotEqual(invoice_ml.account_id, balance_sheet)
+
+    def test_10_link_vendor_bill_line_with_spread_sheet(self):
+        invoice_form = Form(self.vendor_bill)
+        with invoice_form.invoice_line_ids.new() as line:
+            line.name = "new test line"
+            line.quantity = 1.0
+            line.price_unit = 1000.0
+        self.invoice = invoice_form.save()
+
+        self.spread.write(
+            {
+                "estimated_amount": 1000.0,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+                "invoice_line_id": self.vendor_bill_line.id,
+                "move_line_auto_post": False,
+            }
+        )
+
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        expense_account = self.spread.debit_account_id
+        balance_sheet = self.spread.credit_account_id
+        self.assertTrue(balance_sheet.reconcile)
+
+        spread_mls = self.spread.line_ids.mapped("move_id.line_ids")
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertEqual(spread_ml.account_id, expense_account)
+            if spread_ml.credit:
+                self.assertEqual(spread_ml.account_id, balance_sheet)
+
+        # Validate invoice
+        self.vendor_bill.action_post()
+
+        count_balance_sheet = len(
+            self.vendor_bill.line_ids.filtered(lambda x: x.account_id == balance_sheet)
+        )
+        self.assertEqual(count_balance_sheet, 1)
+
+        self.spread.line_ids.create_and_reconcile_moves()
+
+        spread_mls = self.spread.line_ids.mapped("move_id.line_ids")
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertFalse(spread_ml.full_reconcile_id)
+            if spread_ml.credit:
+                self.assertFalse(spread_ml.full_reconcile_id)
+
+        action_posted_view = self.spread2.open_posted_view()
+        self.assertTrue(isinstance(action_posted_view, dict))
+        self.assertFalse(action_posted_view.get("domain")[0][2])
+        self.assertTrue(action_posted_view.get("context"))
+
+    def test_11_link_vendor_bill_line_with_spread_sheet(self):
+        invoice_form = Form(self.vendor_bill)
+        with invoice_form.invoice_line_ids.new() as line:
+            line.name = "new test line"
+            line.quantity = 1.0
+            line.price_unit = 1000.0
+        self.invoice = invoice_form.save()
+        self.spread.write(
+            {
+                "estimated_amount": 1000.0,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+                "invoice_line_id": self.vendor_bill_line.id,
+                "move_line_auto_post": False,
+            }
+        )
+
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        expense_account = self.spread.debit_account_id
+        balance_sheet = self.spread.credit_account_id
+        self.assertTrue(balance_sheet.reconcile)
+
+        spread_mls = self.spread.line_ids.mapped("move_id.line_ids")
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertEqual(spread_ml.account_id, expense_account)
+            if spread_ml.credit:
+                self.assertEqual(spread_ml.account_id, balance_sheet)
+
+        # Validate invoice
+        self.vendor_bill.action_post()
+
+        invoice_mls = self.vendor_bill.line_ids
+        self.assertTrue(invoice_mls)
+
+        count_balance_sheet = len(
+            invoice_mls.filtered(lambda x: x.account_id == balance_sheet)
+        )
+        self.assertEqual(count_balance_sheet, 1)
+
+        self.spread.company_id.force_move_auto_post = True
+        self.spread.line_ids.create_and_reconcile_moves()
+
+        spread_mls = self.spread.line_ids.mapped("move_id.line_ids")
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.credit:
+                self.assertEqual(spread_ml.account_id, balance_sheet)
+                self.assertTrue(spread_ml.full_reconcile_id)
+            if spread_ml.debit:
+                self.assertEqual(spread_ml.account_id, expense_account)
+                self.assertFalse(spread_ml.full_reconcile_id)
+
+        action_posted_view = self.spread.open_posted_view()
+        self.assertTrue(isinstance(action_posted_view, dict))
+        self.assertTrue(action_posted_view.get("domain")[0][2])
+        self.assertTrue(action_posted_view.get("context"))
+
+        action_spread_details = self.vendor_bill_line.spread_details()
+        self.assertTrue(isinstance(action_spread_details, dict))
+        self.assertTrue(action_spread_details.get("res_id"))
+
+    def test_12_link_invoice_line_with_spread_sheet_full_reconcile(self):
+        # Validate invoice
+        self.sale_invoice.action_post()
+
+        self.spread2.write(
+            {
+                "estimated_amount": 1000.0,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+                "invoice_line_id": self.invoice_line.id,
+                "move_line_auto_post": False,
+            }
+        )
+
+        self.assertFalse(any(line.move_id for line in self.spread2.line_ids))
+
+        self.spread2.compute_spread_board()
+        spread_lines = self.spread2.line_ids
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+
+        payable_account = self.spread2.credit_account_id
+        balance_sheet = self.spread2.debit_account_id
+        self.assertTrue(balance_sheet.reconcile)
+
+        spread_mls = self.spread2.line_ids.mapped("move_id.line_ids")
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertEqual(spread_ml.account_id, balance_sheet)
+                self.assertFalse(spread_ml.reconciled)
+                self.assertFalse(spread_ml.full_reconcile_id)
+            if spread_ml.credit:
+                self.assertEqual(spread_ml.account_id, payable_account)
+                self.assertFalse(spread_ml.reconciled)
+                self.assertFalse(spread_ml.full_reconcile_id)
+
+        invoice_mls = self.sale_invoice.invoice_line_ids
+        self.assertTrue(invoice_mls)
+        for invoice_ml in invoice_mls:
+            self.assertEqual(invoice_ml.account_id, balance_sheet)
+
+        action_posted_view = self.spread2.open_posted_view()
+        self.assertTrue(isinstance(action_posted_view, dict))
+        self.assertTrue(action_posted_view.get("domain")[0][2])
+        self.assertFalse(action_posted_view.get("res_id"))
+        self.assertTrue(action_posted_view.get("context"))
+
+        action_spread_details = self.invoice_line.spread_details()
+        self.assertTrue(isinstance(action_spread_details, dict))
+        self.assertTrue(action_spread_details.get("res_id"))
+
+    def test_13_link_invoice_line_with_spread_sheet_partial_reconcile(self):
+        self.spread2.write(
+            {
+                "estimated_amount": 1000.0,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+            }
+        )
+
+        self.spread2.compute_spread_board()
+        spread_lines = self.spread2.line_ids
+        self.assertEqual(len(spread_lines), 13)
+        self.assertFalse(any(line.move_id for line in spread_lines))
+
+        spread_lines[0].create_and_reconcile_moves()
+        spread_lines[1].create_and_reconcile_moves()
+        spread_lines[2].create_and_reconcile_moves()
+        spread_lines[3].create_and_reconcile_moves()
+
+        self.assertEqual(spread_lines[0].move_id.state, "posted")
+        self.assertEqual(spread_lines[1].move_id.state, "posted")
+        self.assertEqual(spread_lines[2].move_id.state, "posted")
+        self.assertEqual(spread_lines[3].move_id.state, "posted")
+        self.assertNotEqual(spread_lines[4].move_id.state, "posted")
+
+        spread_mls = spread_lines[0].move_id.line_ids
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertFalse(spread_ml.matched_debit_ids)
+                self.assertFalse(spread_ml.matched_credit_ids)
+                self.assertFalse(spread_ml.full_reconcile_id)
+            if spread_ml.credit:
+                self.assertFalse(spread_ml.matched_debit_ids)
+                self.assertFalse(spread_ml.matched_credit_ids)
+                self.assertFalse(spread_ml.full_reconcile_id)
+
+        balance_sheet = self.spread2.debit_account_id
+        self.assertTrue(balance_sheet.reconcile)
+
+        # Assing invoice line to spread
+        self.spread2.invoice_line_id = self.invoice_line
+        self.assertEqual(self.invoice_line.spread_id, self.spread2)
+
+        # Validate invoice
+        self.sale_invoice.action_post()
+        invoice_mls = self.sale_invoice.invoice_line_ids
+        self.assertTrue(invoice_mls)
+        for invoice_ml in invoice_mls:
+            self.assertEqual(invoice_ml.account_id, balance_sheet)
+
+        spread_lines = self.spread2.line_ids
+        spread_lines[4].create_and_reconcile_moves()
+
+        self.assertEqual(spread_lines[4].move_id.state, "posted")
+
+        spread_mls = spread_lines[4].move_id.line_ids
+        self.assertTrue(spread_mls)
+        for spread_ml in spread_mls:
+            if spread_ml.debit:
+                self.assertFalse(spread_ml.matched_debit_ids)
+                self.assertTrue(spread_ml.matched_credit_ids)
+                self.assertFalse(spread_ml.full_reconcile_id)
+            if spread_ml.credit:
+                self.assertFalse(spread_ml.matched_debit_ids)
+                self.assertFalse(spread_ml.matched_credit_ids)
+                self.assertFalse(spread_ml.full_reconcile_id)
+
+        other_journal = self.env["account.journal"].create(
+            {"name": "Other Journal", "type": "general", "code": "test2"}
+        )
+        with self.assertRaises(ValidationError):
+            self.spread2.journal_id = other_journal
+
+        with self.assertRaises(UserError):
+            self.spread2.unlink()
+
+    def test_14_create_all_moves(self):
+        self.spread.compute_spread_board()
+
+        self.assertEqual(len(self.spread.line_ids), 12)
+        self.assertFalse(any(line.move_id for line in self.spread.line_ids))
+
+        # create moves for all the spread lines
+        self.spread.create_all_moves()
+        self.assertTrue(all(line.move_id for line in self.spread.line_ids))
+
+        with self.assertRaises(ValidationError):
+            self.spread.unlink()
+
+    def test_15_invoice_refund(self):
+        self.vendor_bill_line.spread_id = self.spread
+
+        # Validate invoice
+        self.vendor_bill.action_post()
+        self.assertTrue(self.vendor_bill.invoice_line_ids.mapped("spread_id"))
+
+        # Create a refund for invoice.
+        move_reversal = (
+            self.env["account.move.reversal"]
+            .with_context(active_model="account.move", active_ids=self.vendor_bill.ids)
+            .create(
+                {
+                    "date": fields.Date.today(),
+                    "reason": "no reason",
+                    "journal_id": self.vendor_bill.journal_id.id,
+                }
+            )
+        )
+        reversal = move_reversal.reverse_moves()
+        refund = self.env["account.move"].browse(reversal["res_id"])
+        self.assertFalse(refund.invoice_line_ids.mapped("spread_id"))

account_spread_cost_revenue/tests/test_account_spread_cost_revenue.py

@@ -0,0 +1,353 @@
+# Copyright 2018-2020 Onestein (<https://www.onestein.eu>)
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import datetime
+
+from psycopg2.errors import NotNullViolation
+
+from odoo.exceptions import ValidationError
+from odoo.tests import Form, common, tagged
+from odoo.tools import mute_logger
+
+
+@tagged("post_install", "-at_install")
+class TestAccountSpreadCostRevenue(common.TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        cls.sales_journal = cls.env["account.journal"].create(
+            {"name": "Customer Invoices - Test", "code": "TEST1", "type": "sale"}
+        )
+
+        cls.expenses_journal = cls.env["account.journal"].create(
+            {"name": "Vendor Bills - Test", "code": "TEST2", "type": "purchase"}
+        )
+
+        cls.credit_account = cls.env["account.account"].create(
+            {
+                "name": "test_account_receivable",
+                "code": "123",
+                "account_type": "asset_receivable",
+                "reconcile": True,
+            }
+        )
+
+        cls.debit_account = cls.env["account.account"].create(
+            {
+                "name": "test account_expenses",
+                "code": "765",
+                "account_type": "expense",
+                "reconcile": True,
+            }
+        )
+
+        cls.account_payable = cls.env["account.account"].create(
+            {
+                "name": "test_account_payable",
+                "code": "321",
+                "account_type": "liability_payable",
+                "reconcile": True,
+            }
+        )
+
+        cls.account_revenue = cls.env["account.account"].create(
+            {
+                "name": "test_account_revenue",
+                "code": "864",
+                "account_type": "asset_receivable",
+                "reconcile": True,
+            }
+        )
+
+    def test_01_account_spread_defaults(self):
+        this_year = datetime.date.today().year
+        spread_template = self.env["account.spread.template"].create(
+            {"name": "test", "spread_account_id": self.debit_account.id}
+        )
+        self.assertEqual(spread_template.spread_type, "sale")
+        self.assertTrue(spread_template.spread_journal_id)
+
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+
+        self.assertTrue(spread)
+        self.assertFalse(spread.line_ids)
+        self.assertFalse(spread.invoice_line_ids)
+        self.assertFalse(spread.invoice_line_id)
+        self.assertFalse(spread.invoice_id)
+        self.assertFalse(spread.analytic_distribution)
+        self.assertTrue(spread.move_line_auto_post)
+        self.assertEqual(spread.name, "test")
+        self.assertEqual(spread.invoice_type, "out_invoice")
+        self.assertEqual(spread.company_id, self.env.company)
+        self.assertEqual(spread.currency_id, self.env.company.currency_id)
+        self.assertEqual(spread.period_number, 12)
+        self.assertEqual(spread.period_type, "month")
+        self.assertEqual(spread.debit_account_id, self.debit_account)
+        self.assertEqual(spread.credit_account_id, self.credit_account)
+        self.assertEqual(spread.unspread_amount, 0.0)
+        self.assertEqual(spread.unposted_amount, 0.0)
+        self.assertEqual(spread.total_amount, 0.0)
+        self.assertEqual(spread.estimated_amount, 0.0)
+        self.assertEqual(spread.spread_date, datetime.date(this_year, 1, 1))
+        self.assertTrue(spread.journal_id)
+        self.assertEqual(spread.journal_id.type, "general")
+
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)
+
+    def test_02_config_defaults(self):
+        self.assertFalse(self.env.company.default_spread_revenue_account_id)
+        self.assertFalse(self.env.company.default_spread_expense_account_id)
+        self.assertFalse(self.env.company.default_spread_revenue_journal_id)
+        self.assertFalse(self.env.company.default_spread_expense_journal_id)
+
+    @mute_logger("odoo.sql_db")
+    def test_03_no_defaults(self):
+        with self.assertRaises(NotNullViolation):
+            self.env["account.spread"].create({"name": "test"})
+        with self.assertRaises(NotNullViolation):
+            self.env["account.spread"].create(
+                {"name": "test", "invoice_type": "out_invoice"}
+            )
+
+    @mute_logger("odoo.sql_db")
+    def test_04_no_defaults(self):
+        with self.assertRaises(NotNullViolation):
+            self.env["account.spread"].create(
+                {
+                    "name": "test",
+                    "debit_account_id": self.debit_account.id,
+                    "credit_account_id": self.credit_account.id,
+                }
+            )
+        with self.assertRaises(NotNullViolation):
+            self.env["account.spread"].create(
+                {
+                    "name": "test",
+                    "credit_account_id": self.credit_account.id,
+                }
+            )
+
+    def test_05_config_settings(self):
+        self.env.company.default_spread_revenue_account_id = self.account_revenue
+        self.env.company.default_spread_expense_account_id = self.account_payable
+        self.env.company.default_spread_revenue_journal_id = self.sales_journal
+        self.env.company.default_spread_expense_journal_id = self.expenses_journal
+
+        self.assertTrue(self.env.company.default_spread_revenue_account_id)
+        self.assertTrue(self.env.company.default_spread_expense_account_id)
+        self.assertTrue(self.env.company.default_spread_revenue_journal_id)
+        self.assertTrue(self.env.company.default_spread_expense_journal_id)
+
+        self.env.user.groups_id += self.env.ref("base.group_multi_company")
+
+        spread_form = Form(self.env["account.spread"])
+        spread_form.name = "test"
+        spread_form.invoice_type = "in_invoice"
+        spread_form.debit_account_id = self.debit_account
+        spread_form.credit_account_id = self.credit_account
+        spread = spread_form.save()
+
+        self.assertTrue(spread)
+        self.assertFalse(spread.line_ids)
+        self.assertFalse(spread.invoice_line_ids)
+        self.assertFalse(spread.invoice_line_id)
+        self.assertFalse(spread.invoice_id)
+        self.assertFalse(spread.analytic_distribution)
+        self.assertTrue(spread.move_line_auto_post)
+
+        defaults = self.env["account.spread"].default_get(["company_id", "currency_id"])
+
+        self.assertEqual(defaults["company_id"], self.env.company.id)
+        self.assertEqual(defaults["currency_id"], self.env.company.currency_id.id)
+
+        spread_form = Form(spread)
+        spread_form.invoice_type = "out_invoice"
+        spread_form.company_id = self.env.company
+        spread = spread_form.save()
+        self.assertEqual(spread.debit_account_id, self.account_revenue)
+        self.assertFalse(spread.is_debit_account_deprecated)
+        self.assertEqual(spread.journal_id, self.sales_journal)
+        self.assertEqual(spread.spread_type, "sale")
+
+        spread_form = Form(spread)
+        spread_form.invoice_type = "in_invoice"
+        spread = spread_form.save()
+        self.assertEqual(spread.credit_account_id, self.account_payable)
+        self.assertFalse(spread.is_credit_account_deprecated)
+        self.assertEqual(spread.journal_id, self.expenses_journal)
+        self.assertEqual(spread.spread_type, "purchase")
+
+    def test_07_create_spread_template(self):
+        spread_template = self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "sale",
+                "spread_account_id": self.account_revenue.id,
+            }
+        )
+
+        self.assertEqual(spread_template.company_id, self.env.company)
+        self.assertTrue(spread_template.spread_journal_id)
+
+        self.env.company.default_spread_revenue_account_id = self.account_revenue
+        self.env.company.default_spread_expense_account_id = self.account_payable
+        self.env.company.default_spread_revenue_journal_id = self.sales_journal
+        self.env.company.default_spread_expense_journal_id = self.expenses_journal
+
+        spread_template.spread_type = "purchase"
+        self.assertTrue(spread_template.spread_journal_id)
+        self.assertTrue(spread_template.spread_account_id)
+        self.assertEqual(spread_template.spread_account_id, self.account_payable)
+        self.assertEqual(spread_template.spread_journal_id, self.expenses_journal)
+
+        spread_vals = spread_template._prepare_spread_from_template()
+        self.assertTrue(spread_vals["name"])
+        self.assertTrue(spread_vals["template_id"])
+        self.assertTrue(spread_vals["journal_id"])
+        self.assertTrue(spread_vals["company_id"])
+        self.assertTrue(spread_vals["invoice_type"])
+        self.assertTrue(spread_vals["credit_account_id"])
+
+        spread_template.spread_type = "sale"
+        self.assertTrue(spread_template.spread_journal_id)
+        self.assertTrue(spread_template.spread_account_id)
+        self.assertEqual(spread_template.spread_account_id, self.account_revenue)
+        self.assertEqual(spread_template.spread_journal_id, self.sales_journal)
+
+        spread_vals = spread_template._prepare_spread_from_template()
+        self.assertTrue(spread_vals["name"])
+        self.assertTrue(spread_vals["template_id"])
+        self.assertTrue(spread_vals["journal_id"])
+        self.assertTrue(spread_vals["company_id"])
+        self.assertTrue(spread_vals["invoice_type"])
+        self.assertTrue(spread_vals["debit_account_id"])
+
+    def test_08_check_template_invoice_type(self):
+        template_sale = self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "sale",
+                "spread_account_id": self.account_revenue.id,
+            }
+        )
+        template_purchase = self.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "purchase",
+                "spread_account_id": self.account_payable.id,
+            }
+        )
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+
+        with self.assertRaises(ValidationError):
+            spread.template_id = template_purchase
+
+        spread.template_id = template_sale
+        self.assertEqual(spread.template_id, template_sale)
+
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)
+
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "in_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+
+        with self.assertRaises(ValidationError):
+            spread.template_id = template_sale
+
+        spread.template_id = template_purchase
+        self.assertEqual(spread.template_id, template_purchase)
+
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)
+
+    def test_10_account_spread_unlink(self):
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+        spread.unlink()
+
+    def test_11_compute_display_fields(self):
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+        spread.company_id.allow_spread_planning = True
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)
+
+    def test_12_compute_display_fields(self):
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+        spread.company_id.allow_spread_planning = False
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)
+
+    def test_13_compute_display_fields(self):
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+        spread.company_id.force_move_auto_post = True
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertFalse(spread.display_move_line_auto_post)
+
+    def test_14_compute_display_fields(self):
+        spread = self.env["account.spread"].create(
+            {
+                "name": "test",
+                "invoice_type": "out_invoice",
+                "debit_account_id": self.debit_account.id,
+                "credit_account_id": self.credit_account.id,
+            }
+        )
+        spread.company_id.force_move_auto_post = False
+        self.assertFalse(spread.display_create_all_moves)
+        self.assertTrue(spread.display_recompute_buttons)
+        self.assertTrue(spread.display_move_line_auto_post)

account_spread_cost_revenue/tests/test_compute_spread_board.py

@@ -0,0 +1,753 @@
+# Copyright 2017-2020 Onestein (<https://www.onestein.eu>)
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import datetime
+import logging
+
+from odoo.exceptions import UserError
+from odoo.tests import Form, common, tagged
+from odoo.tools import mute_logger
+from odoo.tools.misc import lower_logging
+
+
+@tagged("post_install", "-at_install")
+class TestComputeSpreadBoard(common.TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        journal = cls.env["account.journal"].create(
+            {"name": "Test", "type": "general", "code": "test"}
+        )
+        cls.receivable_account = cls.env["account.account"].create(
+            {
+                "name": "test_account_receivable",
+                "code": "123",
+                "account_type": "asset_receivable",
+                "reconcile": True,
+            }
+        )
+        cls.expense_account = cls.env["account.account"].create(
+            {
+                "name": "test account_expenses",
+                "code": "765",
+                "account_type": "expense",
+                "reconcile": True,
+            }
+        )
+
+        cls.spread_account = cls.env["account.account"].create(
+            {
+                "name": "test spread account_expenses",
+                "code": "321",
+                "account_type": "expense",
+                "reconcile": True,
+            }
+        )
+
+        cls.spread = cls.env["account.spread"].create(
+            {
+                "name": "test",
+                "debit_account_id": cls.spread_account.id,
+                "credit_account_id": cls.expense_account.id,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": "2017-02-01",
+                "estimated_amount": 1000.0,
+                "journal_id": journal.id,
+                "invoice_type": "in_invoice",
+            }
+        )
+
+        cls.spread2 = cls.env["account.spread"].create(
+            {
+                "name": "test2",
+                "debit_account_id": cls.spread_account.id,
+                "credit_account_id": cls.expense_account.id,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": "2017-02-01",
+                "estimated_amount": 1000.0,
+                "journal_id": journal.id,
+                "invoice_type": "out_invoice",
+            }
+        )
+
+        cls.spread3 = cls.env["account.spread"].create(
+            {
+                "name": "test by cal days",
+                "debit_account_id": cls.spread_account.id,
+                "credit_account_id": cls.expense_account.id,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": "2017-02-01",
+                "estimated_amount": 12000.0,
+                "journal_id": journal.id,
+                "invoice_type": "out_invoice",
+                "days_calc": True,
+            }
+        )
+
+        cls.template = cls.env["account.spread.template"].create(
+            {
+                "name": "test",
+                "spread_type": "purchase",
+                "period_number": 5,
+                "period_type": "month",
+                "start_date": "2017-01-01",
+                "spread_account_id": cls.spread_account.id,
+                "spread_journal_id": journal.id,
+                "days_calc": True,
+            }
+        )
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_01_supplier_invoice(self):
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 12)
+
+        self.assertEqual(83.33, spread_lines[0].amount)
+        self.assertEqual(83.33, spread_lines[1].amount)
+        self.assertEqual(83.33, spread_lines[2].amount)
+        self.assertEqual(83.33, spread_lines[3].amount)
+        self.assertEqual(83.33, spread_lines[4].amount)
+        self.assertEqual(83.33, spread_lines[5].amount)
+        self.assertEqual(83.33, spread_lines[6].amount)
+        self.assertEqual(83.33, spread_lines[7].amount)
+        self.assertEqual(83.33, spread_lines[8].amount)
+        self.assertEqual(83.33, spread_lines[9].amount)
+        self.assertEqual(83.33, spread_lines[10].amount)
+        self.assertEqual(83.37, spread_lines[11].amount)
+
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[10].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[11].date)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+        for line in spread_lines:
+            line.create_move()
+            self.assertTrue(line.move_id)
+        with lower_logging(25, logging.INFO):
+            self.spread.action_recalculate_spread()
+        spread_lines = self.spread.line_ids
+        for line in spread_lines:
+            self.assertTrue(line.move_id)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_02_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+            }
+        )
+        self.spread_account.reconcile = True
+        self.assertTrue(self.spread_account.reconcile)
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 13)
+
+        self.assertEqual(67.20, spread_lines[0].amount)
+        self.assertEqual(83.33, spread_lines[1].amount)
+        self.assertEqual(83.33, spread_lines[2].amount)
+        self.assertEqual(83.33, spread_lines[3].amount)
+        self.assertEqual(83.33, spread_lines[4].amount)
+        self.assertEqual(83.33, spread_lines[5].amount)
+        self.assertEqual(83.33, spread_lines[6].amount)
+        self.assertEqual(83.33, spread_lines[7].amount)
+        self.assertEqual(83.33, spread_lines[8].amount)
+        self.assertEqual(83.33, spread_lines[9].amount)
+        self.assertEqual(83.33, spread_lines[10].amount)
+        self.assertEqual(83.33, spread_lines[11].amount)
+        self.assertEqual(16.17, spread_lines[12].amount)
+
+        self.assertEqual(datetime.date(2017, 1, 31), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[10].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[11].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[12].date)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+        self.spread.line_ids.create_and_reconcile_moves()
+        for line in self.spread.line_ids:
+            self.assertTrue(line.move_id)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_03_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 31),
+                "move_line_auto_post": False,
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 13)
+        self.assertEqual(2.69, spread_lines[0].amount)
+        self.assertEqual(83.33, spread_lines[1].amount)
+        self.assertEqual(83.33, spread_lines[2].amount)
+        self.assertEqual(83.33, spread_lines[3].amount)
+        self.assertEqual(83.33, spread_lines[4].amount)
+        self.assertEqual(83.33, spread_lines[5].amount)
+        self.assertEqual(83.33, spread_lines[6].amount)
+        self.assertEqual(83.33, spread_lines[7].amount)
+        self.assertEqual(83.33, spread_lines[8].amount)
+        self.assertEqual(83.33, spread_lines[9].amount)
+        self.assertEqual(83.33, spread_lines[10].amount)
+        self.assertEqual(83.33, spread_lines[11].amount)
+        self.assertEqual(80.68, spread_lines[12].amount)
+
+        self.assertEqual(datetime.date(2017, 1, 31), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[10].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[11].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[12].date)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+        spread_lines[0].create_move()
+        spread_lines[1].create_move()
+        spread_lines[2].create_move()
+        self.assertTrue(any(line.move_id for line in spread_lines))
+        self.assertTrue(any(not line.move_id for line in spread_lines))
+
+        self.spread._compute_amounts()
+        self.assertEqual(self.spread.unspread_amount, 830.65)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 13)
+        self.assertEqual(2.69, spread_lines[0].amount)
+        self.assertEqual(83.33, spread_lines[1].amount)
+        self.assertEqual(83.33, spread_lines[2].amount)
+        self.assertEqual(83.33, spread_lines[3].amount)
+        self.assertEqual(83.33, spread_lines[4].amount)
+        self.assertEqual(83.33, spread_lines[5].amount)
+        self.assertEqual(83.33, spread_lines[6].amount)
+        self.assertEqual(83.33, spread_lines[7].amount)
+        self.assertEqual(83.33, spread_lines[8].amount)
+        self.assertEqual(83.33, spread_lines[9].amount)
+        self.assertEqual(83.33, spread_lines[10].amount)
+        self.assertEqual(83.33, spread_lines[11].amount)
+        self.assertEqual(80.68, spread_lines[12].amount)
+
+        self.assertEqual(datetime.date(2017, 1, 31), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[10].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[11].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[12].date)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_04_supplier_invoice(self):
+        self.spread.write(
+            {
+                "credit_account_id": self.expense_account.id,
+                "debit_account_id": self.spread_account.id,
+                "period_number": 3,
+                "period_type": "year",
+                "spread_date": datetime.date(2018, 10, 24),
+            }
+        )
+
+        # change the state of invoice to open by clicking Validate button
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 4)
+        self.assertEqual(333.33, spread_lines[1].amount)
+        self.assertEqual(333.33, spread_lines[2].amount)
+        first_amount = spread_lines[0].amount
+        last_amount = spread_lines[3].amount
+        remaining_amount = first_amount + last_amount
+        self.assertAlmostEqual(remaining_amount, 333.34, places=2)
+        total_line_amount = 0.0
+        for line in spread_lines:
+            total_line_amount += line.amount
+        self.assertAlmostEqual(total_line_amount, 1000.0, places=2)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_05_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 2, 1),
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        # create moves for all the spread lines and open them
+        self.spread.line_ids.create_and_reconcile_moves()
+        for spread_line in self.spread.line_ids:
+            attrs = spread_line.open_move()
+            self.assertTrue(isinstance(attrs, dict))
+
+        # unlink all created moves
+        self.spread.line_ids.unlink_move()
+        for spread_line in self.spread.line_ids:
+            self.assertFalse(spread_line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_06_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {"period_number": 3, "period_type": "quarter", "move_line_auto_post": False}
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+
+        # create moves for all the spread lines and open them
+        self.spread.line_ids.create_and_reconcile_moves()
+
+        # check move lines
+        for spread_line in self.spread.line_ids:
+            for move_line in spread_line.move_id.line_ids:
+                spread_account = self.spread.debit_account_id
+                if move_line.account_id == spread_account:
+                    debit = move_line.debit
+                    self.assertAlmostEqual(debit, spread_line.amount)
+
+        for line in self.spread.line_ids:
+            self.assertTrue(line.move_id)
+            self.assertFalse(line.move_id.state == "posted")
+
+        self.assertEqual(self.spread.unspread_amount, 0.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+        # try to create move lines again: an error is raised
+        for line in self.spread.line_ids:
+            with self.assertRaises(UserError):
+                line.create_move()
+
+        self.spread.write({"move_line_auto_post": True})
+        self.spread.action_recalculate_spread()
+
+        for line in self.spread.line_ids:
+            self.assertTrue(line.move_id)
+            self.assertTrue(line.move_id.state == "posted")
+
+        self.assertEqual(self.spread.unspread_amount, 0.0)
+        self.assertEqual(self.spread.unposted_amount, 0.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_07_supplier_invoice(self):
+        self.spread.write(
+            {
+                "period_number": 3,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 1),
+                "estimated_amount": 345.96,
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 3)
+        self.assertAlmostEqual(115.32, spread_lines[0].amount)
+        self.assertAlmostEqual(115.32, spread_lines[1].amount)
+        self.assertAlmostEqual(115.32, spread_lines[2].amount)
+        self.assertEqual(datetime.date(2017, 1, 31), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[2].date)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        self.assertEqual(self.spread.unspread_amount, 345.96)
+        self.assertEqual(self.spread.unposted_amount, 345.96)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_08_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 2, 1),
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        self.assertTrue(self.spread.line_ids)
+        self.spread.action_undo_spread()
+        self.assertFalse(self.spread.line_ids)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_09_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 2, 1),
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        for line in self.spread.line_ids:
+            line.create_move()
+            self.assertTrue(line.move_id)
+            action = line.open_move()
+            self.assertTrue(action)
+        with lower_logging(25, logging.INFO):
+            self.spread.line_ids.unlink_move()
+        for line in self.spread.line_ids:
+            self.assertFalse(line.move_id)
+        self.assertTrue(self.spread.line_ids)
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_10_create_entries(self):
+        self.env["account.spread.line"]._create_entries()
+        self.assertFalse(self.spread.line_ids)
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        self.env["account.spread.line"]._create_entries()
+        self.assertTrue(self.spread.line_ids)
+        for line in self.spread.line_ids:
+            self.assertTrue(line.move_id)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_11_create_move_sale_invoice(self):
+        self.spread2.move_line_auto_post = False
+        self.spread2.compute_spread_board()
+        for line in self.spread2.line_ids:
+            self.assertFalse(line.move_id)
+            line.create_move()
+            self.assertTrue(line.move_id)
+            self.assertFalse(line.move_id.state == "posted")
+        with lower_logging(25, logging.INFO):
+            self.spread2.action_undo_spread()
+        for line in self.spread2.line_ids:
+            self.assertFalse(line.move_id)
+        with lower_logging(25, logging.INFO):
+            self.spread2.action_recalculate_spread()
+        for line in self.spread2.line_ids:
+            self.assertTrue(line.move_id)
+            self.assertTrue(line.move_id)
+            self.assertFalse(line.move_id.state == "posted")
+            # try to create move lines again: an error is raised
+            with self.assertRaises(UserError):
+                line.create_move()
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_12_supplier_invoice_auto_post(self):
+        # spread date set
+        self.spread.write(
+            {"period_number": 8, "period_type": "month", "move_line_auto_post": True}
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+
+        # create moves for all the spread lines and open them
+        self.spread.line_ids.create_and_reconcile_moves()
+
+        # check move lines
+        for spread_line in self.spread.line_ids:
+            for move_line in spread_line.move_id.line_ids:
+                spread_account = self.spread.debit_account_id
+                if move_line.account_id == spread_account:
+                    debit = move_line.debit
+                    self.assertAlmostEqual(debit, spread_line.amount)
+
+        self.assertTrue(self.spread.move_line_auto_post)
+        for line in self.spread.line_ids:
+            self.assertTrue(line.move_id)
+            self.assertTrue(line.move_id.state == "posted")
+
+        self.assertEqual(self.spread.unspread_amount, 0.0)
+        self.assertEqual(self.spread.unposted_amount, 0.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_13_create_move_in_invoice_auto_post(self):
+        self.spread2.write({"period_number": 4, "move_line_auto_post": True})
+        self.spread_account.reconcile = True
+        self.assertTrue(self.spread_account.reconcile)
+        with lower_logging(25, logging.INFO):
+            self.spread2.compute_spread_board()
+        for line in self.spread2.line_ids:
+            self.assertFalse(line.move_id)
+            line.create_move()
+            self.assertTrue(line.move_id)
+            self.assertTrue(line.move_id.state == "posted")
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_14_negative_amount(self):
+        # spread date set
+        self.spread.write(
+            {
+                "estimated_amount": -1000.0,
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+            }
+        )
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+
+        spread_lines = self.spread.line_ids
+        self.assertTrue(spread_lines)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_15_compute_spread_board_line_account_deprecated(self):
+        self.spread.debit_account_id.deprecated = True
+        self.assertTrue(self.spread.debit_account_id.deprecated)
+
+        self.assertTrue(self.spread.is_debit_account_deprecated)
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_16_compute_spread_board_line_account_deprecated(self):
+        self.spread.credit_account_id.deprecated = True
+        self.assertTrue(self.spread.credit_account_id.deprecated)
+
+        self.assertTrue(self.spread.is_credit_account_deprecated)
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_17_compute_spread_board_line_account_deprecated(self):
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        self.spread.debit_account_id.deprecated = True
+        self.assertTrue(self.spread.debit_account_id.deprecated)
+
+        for line in self.spread.line_ids:
+            self.assertFalse(line.move_id)
+            with self.assertRaises(UserError):
+                line.create_move()
+
+        self.assertEqual(self.spread.unspread_amount, 1000.0)
+        self.assertEqual(self.spread.unposted_amount, 1000.0)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_18_supplier_invoice(self):
+        # spread date set
+        self.spread.write(
+            {
+                "period_number": 12,
+                "period_type": "month",
+                "spread_date": datetime.date(2017, 1, 7),
+            }
+        )
+        self.spread_account.reconcile = True
+        self.assertTrue(self.spread_account.reconcile)
+        with lower_logging(25, logging.INFO):
+            self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 13)
+
+        for line in spread_lines:
+            self.assertFalse(line.move_id)
+
+        spread_lines[0]._create_moves().action_post()
+        spread_lines[1]._create_moves().action_post()
+        spread_lines[2]._create_moves().action_post()
+        spread_lines[3]._create_moves().action_post()
+
+        self.assertEqual(spread_lines[0].move_id.state, "posted")
+        self.assertEqual(spread_lines[1].move_id.state, "posted")
+        self.assertEqual(spread_lines[2].move_id.state, "posted")
+        self.assertEqual(spread_lines[3].move_id.state, "posted")
+
+        self.assertAlmostEqual(self.spread.unspread_amount, 682.81)
+        self.assertAlmostEqual(self.spread.unposted_amount, 682.81)
+
+        self.spread.compute_spread_board()
+        spread_lines = self.spread.line_ids
+        self.assertEqual(len(spread_lines), 13)
+
+        self.assertEqual(67.20, spread_lines[0].amount)
+        self.assertEqual(83.33, spread_lines[1].amount)
+        self.assertEqual(83.33, spread_lines[2].amount)
+        self.assertEqual(83.33, spread_lines[3].amount)
+        self.assertEqual(83.33, spread_lines[4].amount)
+        self.assertEqual(83.33, spread_lines[5].amount)
+        self.assertEqual(83.33, spread_lines[6].amount)
+        self.assertEqual(83.33, spread_lines[7].amount)
+        self.assertEqual(83.33, spread_lines[8].amount)
+        self.assertEqual(83.33, spread_lines[9].amount)
+        self.assertEqual(83.33, spread_lines[10].amount)
+        self.assertEqual(83.33, spread_lines[11].amount)
+        self.assertEqual(16.17, spread_lines[12].amount)
+
+        self.assertEqual(datetime.date(2017, 1, 31), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[10].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[11].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[12].date)
+
+        self.assertAlmostEqual(self.spread.unspread_amount, 682.81)
+        self.assertAlmostEqual(self.spread.unposted_amount, 682.81)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_19_supplier_invoice_calc_day(self):
+        self.assertTrue(self.spread3.days_calc)
+        self.spread3.compute_spread_board()
+        spread_lines = self.spread3.line_ids
+        self.assertEqual(len(spread_lines), 12)
+        # Calculate by day has formula:
+        # (amount spread cost / all spread cost day) * day of <period_type>
+        self.assertAlmostEqual(920.55, spread_lines[0].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[1].amount)
+        self.assertAlmostEqual(986.30, spread_lines[2].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[3].amount)
+        self.assertAlmostEqual(986.30, spread_lines[4].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[5].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[6].amount)
+        self.assertAlmostEqual(986.30, spread_lines[7].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[8].amount)
+        self.assertAlmostEqual(986.30, spread_lines[9].amount)
+        self.assertAlmostEqual(1019.18, spread_lines[10].amount)
+        self.assertAlmostEqual(1019.17, spread_lines[11].amount)  # total left
+
+        self.assertEqual(datetime.date(2017, 2, 28), spread_lines[0].date)
+        self.assertEqual(datetime.date(2017, 3, 31), spread_lines[1].date)
+        self.assertEqual(datetime.date(2017, 4, 30), spread_lines[2].date)
+        self.assertEqual(datetime.date(2017, 5, 31), spread_lines[3].date)
+        self.assertEqual(datetime.date(2017, 6, 30), spread_lines[4].date)
+        self.assertEqual(datetime.date(2017, 7, 31), spread_lines[5].date)
+        self.assertEqual(datetime.date(2017, 8, 31), spread_lines[6].date)
+        self.assertEqual(datetime.date(2017, 9, 30), spread_lines[7].date)
+        self.assertEqual(datetime.date(2017, 10, 31), spread_lines[8].date)
+        self.assertEqual(datetime.date(2017, 11, 30), spread_lines[9].date)
+        self.assertEqual(datetime.date(2017, 12, 31), spread_lines[10].date)
+        self.assertEqual(datetime.date(2018, 1, 31), spread_lines[11].date)
+
+        # Period Type is 'Quarter'
+        self.spread3.period_type = "quarter"
+        with lower_logging(25, logging.INFO):
+            self.spread3.compute_spread_board()
+        spread_lines = self.spread3.line_ids
+        self.assertEqual(len(spread_lines), 12)
+        self.assertAlmostEqual(325.27, spread_lines[0].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[1].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[2].amount)
+        self.assertAlmostEqual(1057.12, spread_lines[3].amount)
+        self.assertAlmostEqual(1045.50, spread_lines[4].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[5].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[6].amount)
+        self.assertAlmostEqual(1057.12, spread_lines[7].amount)
+        self.assertAlmostEqual(1045.50, spread_lines[8].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[9].amount)
+        self.assertAlmostEqual(1068.73, spread_lines[10].amount)
+        self.assertAlmostEqual(1057.11, spread_lines[11].amount)  # total left
+
+        # Period Type is 'Year' and spread date is not first month
+        self.spread3.period_type = "year"
+        self.spread3.spread_date = "2017-02-02"
+        self.spread3.compute_spread_board()
+        spread_lines = self.spread3.line_ids
+        self.assertEqual(len(spread_lines), 13)
+        self.assertAlmostEqual(73.92, spread_lines[0].amount)
+        self.assertAlmostEqual(999.32, spread_lines[1].amount)
+        self.assertAlmostEqual(999.32, spread_lines[2].amount)
+        self.assertAlmostEqual(1002.05, spread_lines[3].amount)
+        self.assertAlmostEqual(999.32, spread_lines[4].amount)
+        self.assertAlmostEqual(999.32, spread_lines[5].amount)
+        self.assertAlmostEqual(999.32, spread_lines[6].amount)
+        self.assertAlmostEqual(1002.05, spread_lines[7].amount)
+        self.assertAlmostEqual(999.32, spread_lines[8].amount)
+        self.assertAlmostEqual(999.32, spread_lines[9].amount)
+        self.assertAlmostEqual(999.32, spread_lines[10].amount)
+        self.assertAlmostEqual(1002.05, spread_lines[11].amount)
+        self.assertAlmostEqual(925.37, spread_lines[12].amount)
+
+    @mute_logger("odoo.models", "odoo.sql_db", "odoo.models.unlink")
+    def test_20_supplier_invoice_template(self):
+        """Test onchange template"""
+        self.assertEqual(self.spread3.invoice_type, "out_invoice")
+        with Form(self.spread3) as sp:
+            sp.template_id = self.template
+            sp.credit_account_id = self.expense_account
+        sp.save()
+        self.assertEqual(self.spread3.invoice_type, "in_invoice")