odoo-addon-contract 17.0.1.4.3.2__py3-none-any.whl → 18.0.2.0.8__py3-none-any.whl

odoo/addons/contract/tests/test_contract.py

@@ -5,13 +5,12 @@
 
 import logging
 from collections import namedtuple
-from datetime import timedelta
 
 from dateutil.relativedelta import relativedelta
 from freezegun import freeze_time
 
-from odoo import fields
-from odoo.exceptions import UserError, ValidationError
+from odoo import Command, fields
+from odoo.exceptions import ValidationError
 from odoo.tests import Form, common
 
 
@@ -37,7 +36,11 @@ class TestContractBase(common.TransactionCase):
         cls.product_1 = cls.env.ref("product.product_product_1")
         cls.product_2 = cls.env.ref("product.product_product_2")
         cls.product_1.taxes_id += cls.env["account.tax"].search(
-            [("type_tax_use", "=", "sale")], limit=1
+            [
+                ("type_tax_use", "=", "sale"),
+                ("company_id", "=", cls.env.company.id),
+            ],
+            limit=1,
         )
         cls.product_1.description_sale = "Test description sale"
         cls.line_template_vals = {
@@ -57,8 +60,8 @@ class TestContractBase(common.TransactionCase):
         cls.template_vals = {
             "name": "Test Contract Template",
             "contract_line_ids": [
-                (0, 0, cls.section_template_vals),
-                (0, 0, cls.line_template_vals),
+                Command.create(cls.section_template_vals),
+                Command.create(cls.line_template_vals),
             ],
         }
         cls.template = cls.env["contract.template"].create(cls.template_vals)
@@ -71,6 +74,24 @@ class TestContractBase(common.TransactionCase):
                 "base": "list_price",
             }
         )
+        cls.env["product.pricelist.item"].create(
+            {
+                "pricelist_id": cls.partner.property_product_pricelist.id,
+                "product_id": cls.product_2.id,
+                "compute_price": "fixed",
+                "fixed_price": 100,
+                "min_quantity": 1,
+            }
+        )
+        cls.env["product.pricelist.item"].create(
+            {
+                "pricelist_id": cls.partner.property_product_pricelist.id,
+                "product_id": cls.product_2.id,
+                "compute_price": "fixed",
+                "fixed_price": 50,
+                "min_quantity": 10,
+            }
+        )
         cls.contract = cls.env["contract.contract"].create(
             {
                 "name": "Test Contract",
@@ -87,9 +108,7 @@ class TestContractBase(common.TransactionCase):
                 "line_recurrence": True,
                 "contract_type": "purchase",
                 "contract_line_ids": [
-                    (
-                        0,
-                        0,
+                    Command.create(
                         {
                             "product_id": cls.product_1.id,
                             "name": "Services from #START# to #END#",
@@ -118,14 +137,8 @@ class TestContractBase(common.TransactionCase):
             "recurring_interval": 1,
             "date_start": "2018-01-01",
             "recurring_next_date": "2018-01-15",
-            "is_auto_renew": False,
         }
         cls.acct_line = cls.env["contract.line"].create(cls.line_vals)
-        cls.contract.company_id.create_new_line_at_contract_line_renew = True
-        cls.terminate_reason = cls.env["contract.terminate.reason"].create(
-            {"name": "terminate_reason"}
-        )
-
         cls.contract3 = cls.env["contract.contract"].create(
             {
                 "name": "Test Contract 3",
@@ -137,18 +150,14 @@ class TestContractBase(common.TransactionCase):
                 "recurring_rule_type": "monthly",
                 "date_start": "2018-02-15",
                 "contract_line_ids": [
-                    (
-                        0,
-                        0,
+                    Command.create(
                         {
                             "product_id": False,
                             "name": "Header for #INVOICEMONTHNAME# Services",
                             "display_type": "line_section",
                         },
                     ),
-                    (
-                        0,
-                        0,
+                    Command.create(
                         {
                             "product_id": False,
                             "name": "Services from #START# to #END#",
@@ -156,9 +165,7 @@ class TestContractBase(common.TransactionCase):
                             "price_unit": 100,
                         },
                     ),
-                    (
-                        0,
-                        0,
+                    Command.create(
                         {
                             "product_id": False,
                             "name": "Line",
@@ -221,8 +228,12 @@ class TestContract(TestContractBase):
         self.contract.write(
             {
                 "modification_ids": [
-                    (0, 0, {"date": "2020-01-01", "description": "Modification 1"}),
-                    (0, 0, {"date": "2020-02-01", "description": "Modification 2"}),
+                    Command.create(
+                        {"date": "2020-01-01", "description": "Modification 1"}
+                    ),
+                    Command.create(
+                        {"date": "2020-02-01", "description": "Modification 2"}
+                    ),
                 ]
             }
         )
@@ -251,6 +262,31 @@ class TestContract(TestContractBase):
         self.acct_line.invalidate_model()
         self.assertEqual(self.acct_line.price_unit, 10)
 
+    def test_automatic_price_min_quantity(self):
+        """Test that automatic pricing respects pricelist quantity-based rules."""
+        self.acct_line.product_id = self.product_2.id
+        self.acct_line.automatic_price = True
+        self.acct_line.quantity = 1
+        self.assertEqual(
+            self.acct_line.price_unit,
+            100,
+            "Price should be 100 for quantity 1 based on pricelist rule",
+        )
+        self.acct_line.quantity = 10
+        self.assertEqual(
+            self.acct_line.price_unit,
+            50,
+            "Price should be 50 for quantity 10 based on pricelist rule",
+        )
+
+    def test_automatic_price_change(self):
+        self.acct_line.automatic_price = True
+        self.product_1.list_price = 1100
+        self.assertEqual(self.acct_line.price_unit, 1100)
+        # Change contract type
+        self.acct_line.contract_id.contract_type = "purchase"
+        self.assertFalse(self.acct_line.automatic_price)
+
     def test_contract(self):
         self.assertEqual(self.contract.recurring_next_date, to_date("2018-01-15"))
         self.assertAlmostEqual(self.acct_line.price_subtotal, 50.0)
@@ -272,9 +308,9 @@ class TestContract(TestContractBase):
     def test_contract_daily(self):
         recurring_next_date = to_date("2018-02-23")
         last_date_invoiced = to_date("2018-02-22")
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "daily"
         self.contract.pricelist_id = False
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoice_daily = self.contract._get_related_invoices()
         self.assertTrue(invoice_daily)
@@ -315,9 +351,9 @@ class TestContract(TestContractBase):
     def test_contract_weekly_post_paid(self):
         recurring_next_date = to_date("2018-03-01")
         last_date_invoiced = to_date("2018-02-21")
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "weekly"
         self.acct_line.recurring_invoicing_type = "post-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -327,9 +363,9 @@ class TestContract(TestContractBase):
     def test_contract_weekly_pre_paid(self):
         recurring_next_date = to_date("2018-03-01")
         last_date_invoiced = to_date("2018-02-28")
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "weekly"
         self.acct_line.recurring_invoicing_type = "pre-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -339,9 +375,9 @@ class TestContract(TestContractBase):
     def test_contract_yearly_post_paid(self):
         recurring_next_date = to_date("2019-02-22")
         last_date_invoiced = to_date("2018-02-21")
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "yearly"
         self.acct_line.recurring_invoicing_type = "post-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -352,9 +388,9 @@ class TestContract(TestContractBase):
         recurring_next_date = to_date("2019-02-22")
         last_date_invoiced = to_date("2019-02-21")
         self.acct_line.date_end = "2020-02-22"
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "yearly"
         self.acct_line.recurring_invoicing_type = "pre-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -364,9 +400,9 @@ class TestContract(TestContractBase):
     def test_contract_monthly_lastday(self):
         recurring_next_date = to_date("2018-02-28")
         last_date_invoiced = to_date("2018-02-22")
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_invoicing_type = "post-paid"
         self.acct_line.recurring_rule_type = "monthlylastday"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_monthly_lastday = self.contract._get_related_invoices()
         self.assertTrue(invoices_monthly_lastday)
@@ -377,9 +413,9 @@ class TestContract(TestContractBase):
         recurring_next_date = to_date("2018-05-22")
         last_date_invoiced = to_date("2018-05-21")
         self.acct_line.date_end = "2020-02-22"
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "quarterly"
         self.acct_line.recurring_invoicing_type = "pre-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -390,9 +426,9 @@ class TestContract(TestContractBase):
         recurring_next_date = to_date("2018-05-22")
         last_date_invoiced = to_date("2018-02-21")
         self.acct_line.date_end = "2020-02-22"
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "quarterly"
         self.acct_line.recurring_invoicing_type = "post-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -403,9 +439,9 @@ class TestContract(TestContractBase):
         recurring_next_date = to_date("2018-08-22")
         last_date_invoiced = to_date("2018-08-21")
         self.acct_line.date_end = "2020-02-22"
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "semesterly"
         self.acct_line.recurring_invoicing_type = "pre-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -416,9 +452,9 @@ class TestContract(TestContractBase):
         recurring_next_date = to_date("2018-08-22")
         last_date_invoiced = to_date("2018-02-21")
         self.acct_line.date_end = "2020-02-22"
-        self.acct_line.recurring_next_date = "2018-02-22"
         self.acct_line.recurring_rule_type = "semesterly"
         self.acct_line.recurring_invoicing_type = "post-paid"
+        self.acct_line.recurring_next_date = "2018-02-22"
         self.contract.recurring_create_invoice()
         invoices_weekly = self.contract._get_related_invoices()
         self.assertTrue(invoices_weekly)
@@ -487,7 +523,9 @@ class TestContract(TestContractBase):
     def test_uom(self):
         uom_litre = self.env.ref("uom.product_uom_litre")
         self.acct_line.uom_id = uom_litre.id
-        self.acct_line._onchange_product_id()
+        product = self.acct_line.product_id
+        self.acct_line.product_id = False
+        self.acct_line.product_id = product
         self.assertEqual(self.acct_line.uom_id, self.acct_line.product_id.uom_id)
 
     def test_no_pricelist(self):
@@ -519,10 +557,10 @@ class TestContract(TestContractBase):
         self.contract._onchange_contract_template_id()
         res = {
             "contract_line_ids": [
-                (0, 0, {"display_type": "line_section", "name": "Test section"}),
-                (
-                    0,
-                    0,
+                Command.create(
+                    {"display_type": "line_section", "name": "Test section"}
+                ),
+                Command.create(
                     {
                         "product_id": self.product_1.id,
                         "name": "Services from #START# to #END#",
@@ -541,7 +579,6 @@ class TestContract(TestContractBase):
 
     def test_onchange_contract_template_id_lines(self):
         """It should create invoice lines for the contract lines."""
-        self.acct_line.cancel()
         self.acct_line.unlink()
         self.contract.contract_template_id = self.template
 
@@ -576,28 +613,11 @@ class TestContract(TestContractBase):
         result = self.contract.action_contract_send()
         self.assertEqual(result["res_model"], "mail.compose.message")
 
-    def test_onchange_contract_type(self):
-        self.contract._onchange_contract_type()
-        self.assertEqual(self.contract.journal_id.type, "sale")
-        self.assertEqual(self.contract.journal_id.company_id, self.contract.company_id)
-        self.contract.contract_type = "purchase"
-        self.contract._onchange_contract_type()
-        self.assertFalse(any(self.contract.contract_line_ids.mapped("automatic_price")))
-
-    def test_contract_onchange_product_id_uom(self):
-        """It should update the UoM for the line."""
-        line = self._add_template_line(
-            {"uom_id": self.env.ref("uom.product_uom_litre").id}
-        )
-        line.product_id.uom_id = self.env.ref("uom.product_uom_day").id
-        line._onchange_product_id()
-        self.assertEqual(line.uom_id, line.product_id.uom_id)
-
     def test_contract_onchange_product_id_name(self):
         """It should update the name for the line."""
         line = self._add_template_line()
-        line.product_id.description_sale = "Test"
-        line._onchange_product_id()
+        self.product_2.description_sale = "Test Name Change"
+        line.product_id = self.product_2
         self.assertEqual(
             line.name, line.product_id.get_product_multiline_description_sale()
         )
@@ -1096,629 +1116,6 @@ class TestContract(TestContractBase):
             min(self.contract.contract_line_ids.mapped("recurring_next_date")),
         )
 
-    def test_date_end(self):
-        """recurring next date for a contract is the min for all lines"""
-        self.acct_line.date_end = "2018-01-01"
-        self.acct_line.copy()
-        self.acct_line.write({"date_end": False, "is_auto_renew": False})
-        self.assertFalse(self.contract.date_end)
-
-    def test_cancel_contract_line(self):
-        """It should raise a validation error"""
-        self.acct_line.cancel()
-        with self.assertRaises(ValidationError):
-            self.acct_line.stop(self.today)
-
-    def test_stop_contract_line(self):
-        """It should put end to the contract line"""
-        self.acct_line.write(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=7),
-                "is_auto_renew": True,
-            }
-        )
-        self.acct_line.stop(self.today + relativedelta(months=5))
-        self.assertEqual(self.acct_line.date_end, self.today + relativedelta(months=5))
-
-    def test_stop_upcoming_contract_line(self):
-        """It should put end to the contract line"""
-        self.acct_line.write(
-            {
-                "date_start": self.today + relativedelta(months=3),
-                "recurring_next_date": self.today + relativedelta(months=3),
-                "date_end": self.today + relativedelta(months=7),
-                "is_auto_renew": True,
-            }
-        )
-        self.acct_line.stop(self.today)
-        self.assertEqual(self.acct_line.date_end, self.today + relativedelta(months=7))
-        self.assertTrue(self.acct_line.is_canceled)
-
-    def test_stop_past_contract_line(self):
-        """Past contract line are ignored on stop"""
-        self.acct_line.write(
-            {"date_end": self.today + relativedelta(months=5), "is_auto_renew": True}
-        )
-        self.acct_line.stop(self.today + relativedelta(months=7))
-        self.assertEqual(self.acct_line.date_end, self.today + relativedelta(months=5))
-
-    def test_stop_contract_line_without_date_end(self):
-        """Past contract line are ignored on stop"""
-        self.acct_line.write({"date_end": False, "is_auto_renew": False})
-        self.acct_line.stop(self.today + relativedelta(months=7))
-        self.assertEqual(self.acct_line.date_end, self.today + relativedelta(months=7))
-
-    def test_stop_wizard(self):
-        self.acct_line.write(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=5),
-                "is_auto_renew": True,
-            }
-        )
-        wizard = self.env["contract.line.wizard"].create(
-            {
-                "date_end": self.today + relativedelta(months=3),
-                "contract_line_id": self.acct_line.id,
-            }
-        )
-        wizard.stop()
-        self.assertEqual(self.acct_line.date_end, self.today + relativedelta(months=3))
-        self.assertFalse(self.acct_line.is_auto_renew)
-
-    def test_stop_plan_successor_contract_line_0(self):
-        successor_contract_line = self.acct_line.copy(
-            {
-                "date_start": self.today + relativedelta(months=5),
-                "recurring_next_date": self.today + relativedelta(months=5),
-            }
-        )
-        self.acct_line.write(
-            {
-                "successor_contract_line_id": successor_contract_line.id,
-                "is_auto_renew": False,
-                "date_end": self.today,
-            }
-        )
-        suspension_start = self.today + relativedelta(months=5)
-        suspension_end = self.today + relativedelta(months=6)
-        with self.assertRaises(ValidationError):
-            self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-
-    def test_stop_plan_successor_contract_line_1(self):
-        """
-        * contract line end's before the suspension period:
-                -> apply stop
-        """
-        suspension_start = self.today + relativedelta(months=5)
-        suspension_end = self.today + relativedelta(months=6)
-        start_date = self.today
-        end_date = self.today + relativedelta(months=4)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(self.acct_line.date_end, end_date)
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_contract_line_2(self):
-        """
-        * contract line start before the suspension period and end in it
-                -> apply stop at suspension start date
-                -> apply plan successor:
-                    - date_start: suspension.date_end
-                    - date_end: suspension.date_end + (contract_line.date_end
-                                                    - suspension.date_start)
-        """
-        suspension_start = self.today + relativedelta(months=3)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today
-        end_date = self.today + relativedelta(months=4)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_end, suspension_start - relativedelta(days=1)
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertTrue(new_line)
-        new_date_end = (
-            suspension_end + (end_date - suspension_start) + relativedelta(days=1)
-        )
-        self.assertEqual(new_line.date_start, suspension_end + relativedelta(days=1))
-        self.assertEqual(new_line.date_end, new_date_end)
-        self.assertTrue(self.acct_line.manual_renew_needed)
-
-    def test_stop_plan_successor_contract_line_3(self):
-        """
-        * contract line start before the suspension period and end after it
-                -> apply stop at suspension start date
-                -> apply plan successor:
-                    - date_start: suspension.date_end
-                    - date_end: suspension.date_end + (suspension.date_end
-                                                    - suspension.date_start)
-        """
-        suspension_start = self.today + relativedelta(months=3)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today
-        end_date = self.today + relativedelta(months=6)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_end, suspension_start - relativedelta(days=1)
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertTrue(new_line)
-        new_date_end = (
-            end_date + (suspension_end - suspension_start) + relativedelta(days=1)
-        )
-        self.assertEqual(new_line.date_start, suspension_end + relativedelta(days=1))
-        self.assertEqual(new_line.date_end, new_date_end)
-        self.assertTrue(self.acct_line.manual_renew_needed)
-
-    def test_stop_plan_successor_contract_line_3_without_end_date(self):
-        """
-        * contract line start before the suspension period and end after it
-                -> apply stop at suspension start date
-                -> apply plan successor:
-                    - date_start: suspension.date_end
-                    - date_end: suspension.date_end + (suspension.date_end
-                                                    - suspension.date_start)
-        """
-        suspension_start = self.today + relativedelta(months=3)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today
-        end_date = False
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-                "is_auto_renew": False,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, False)
-        self.assertEqual(
-            self.acct_line.date_end, suspension_start - relativedelta(days=1)
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertTrue(new_line)
-        self.assertEqual(new_line.date_start, suspension_end + relativedelta(days=1))
-        self.assertFalse(new_line.date_end)
-        self.assertTrue(self.acct_line.manual_renew_needed)
-
-    def test_stop_plan_successor_contract_line_4(self):
-        """
-        * contract line start and end's in the suspension period
-                -> apply delay
-                    - delay: suspension.date_end - contract_line.end_date
-        """
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today + relativedelta(months=3)
-        end_date = self.today + relativedelta(months=4)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - start_date) + timedelta(days=1),
-        )
-        self.assertEqual(
-            self.acct_line.date_end,
-            end_date + (suspension_end - start_date) + timedelta(days=1),
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_contract_line_5(self):
-        """
-        * contract line start in the suspension period and end after it
-                -> apply delay
-                    - delay: suspension.date_end - contract_line.date_start
-        """
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today + relativedelta(months=3)
-        end_date = self.today + relativedelta(months=6)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - start_date) + timedelta(days=1),
-        )
-        self.assertEqual(
-            self.acct_line.date_end,
-            end_date + (suspension_end - start_date) + timedelta(days=1),
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_contract_line_5_without_date_end(self):
-        """
-        * contract line start in the suspension period and end after it
-                -> apply delay
-                    - delay: suspension.date_end - contract_line.date_start
-        """
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today + relativedelta(months=3)
-        end_date = False
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-                "is_auto_renew": False,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - start_date) + timedelta(days=1),
-        )
-        self.assertFalse(self.acct_line.date_end)
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_contract_line_6(self):
-        """
-        * contract line start  and end after the suspension period
-                -> apply delay
-                    - delay: suspension.date_end - suspension.start_date
-        """
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=3)
-        start_date = self.today + relativedelta(months=4)
-        end_date = self.today + relativedelta(months=6)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - suspension_start) + timedelta(days=1),
-        )
-        self.assertEqual(
-            self.acct_line.date_end,
-            end_date + (suspension_end - suspension_start) + timedelta(days=1),
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_contract_line_6_without_date_end(self):
-        """
-        * contract line start  and end after the suspension period
-                -> apply delay
-                    - delay: suspension.date_end - suspension.start_date
-        """
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=3)
-        start_date = self.today + relativedelta(months=4)
-        end_date = False
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-                "is_auto_renew": False,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - suspension_start) + timedelta(days=1),
-        )
-        self.assertFalse(self.acct_line.date_end)
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_stop_plan_successor_wizard(self):
-        suspension_start = self.today + relativedelta(months=2)
-        suspension_end = self.today + relativedelta(months=3)
-        start_date = self.today + relativedelta(months=4)
-        end_date = self.today + relativedelta(months=6)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        wizard = self.env["contract.line.wizard"].create(
-            {
-                "date_start": suspension_start,
-                "date_end": suspension_end,
-                "is_auto_renew": False,
-                "contract_line_id": self.acct_line.id,
-            }
-        )
-        wizard.stop_plan_successor()
-        self.assertEqual(
-            self.acct_line.date_start,
-            start_date + (suspension_end - suspension_start) + timedelta(days=1),
-        )
-        self.assertEqual(
-            self.acct_line.date_end,
-            end_date + (suspension_end - suspension_start) + timedelta(days=1),
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(new_line)
-
-    def test_plan_successor_contract_line(self):
-        self.acct_line.write(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=3),
-                "is_auto_renew": False,
-            }
-        )
-        self.acct_line.plan_successor(
-            self.today + relativedelta(months=5),
-            self.today + relativedelta(months=7),
-            True,
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(self.acct_line.is_auto_renew)
-        self.assertTrue(new_line.is_auto_renew)
-        self.assertTrue(new_line, "should create a new contract line")
-        self.assertEqual(new_line.date_start, self.today + relativedelta(months=5))
-        self.assertEqual(new_line.date_end, self.today + relativedelta(months=7))
-
-    def test_overlap(self):
-        self.acct_line.write(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=3),
-                "is_auto_renew": False,
-            }
-        )
-        self.acct_line.plan_successor(
-            self.today + relativedelta(months=5),
-            self.today + relativedelta(months=7),
-            True,
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        with self.assertRaises(ValidationError):
-            new_line.date_start = self.today + relativedelta(months=2)
-        with self.assertRaises(ValidationError):
-            self.acct_line.date_end = self.today + relativedelta(months=6)
-
-    def test_plan_successor_wizard(self):
-        self.acct_line.write(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=2),
-                "is_auto_renew": False,
-            }
-        )
-        wizard = self.env["contract.line.wizard"].create(
-            {
-                "date_start": self.today + relativedelta(months=3),
-                "date_end": self.today + relativedelta(months=5),
-                "is_auto_renew": True,
-                "contract_line_id": self.acct_line.id,
-            }
-        )
-        wizard.plan_successor()
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertFalse(self.acct_line.is_auto_renew)
-        self.assertTrue(new_line.is_auto_renew)
-        self.assertTrue(new_line, "should create a new contract line")
-        self.assertEqual(new_line.date_start, self.today + relativedelta(months=3))
-        self.assertEqual(new_line.date_end, self.today + relativedelta(months=5))
-
-    def test_cancel(self):
-        self.acct_line.write(
-            {"date_end": self.today + relativedelta(months=5), "is_auto_renew": True}
-        )
-        self.acct_line.cancel()
-        self.assertTrue(self.acct_line.is_canceled)
-        self.assertFalse(self.acct_line.is_auto_renew)
-        with self.assertRaises(ValidationError):
-            self.acct_line.is_auto_renew = True
-        self.acct_line.uncancel(self.today)
-        self.assertFalse(self.acct_line.is_canceled)
-
-    def test_uncancel_wizard(self):
-        self.acct_line.cancel()
-        self.assertTrue(self.acct_line.is_canceled)
-        wizard = self.env["contract.line.wizard"].create(
-            {"recurring_next_date": self.today, "contract_line_id": self.acct_line.id}
-        )
-        wizard.uncancel()
-        self.assertFalse(self.acct_line.is_canceled)
-
-    def test_cancel_uncancel_with_predecessor(self):
-        suspension_start = self.today + relativedelta(months=3)
-        suspension_end = self.today + relativedelta(months=5)
-        start_date = self.today
-        end_date = self.today + relativedelta(months=4)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        self.assertEqual(
-            self.acct_line.date_end, suspension_start - relativedelta(days=1)
-        )
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        self.assertEqual(self.acct_line.successor_contract_line_id, new_line)
-        new_line.cancel()
-        self.assertTrue(new_line.is_canceled)
-        self.assertFalse(self.acct_line.successor_contract_line_id)
-        self.assertEqual(new_line.predecessor_contract_line_id, self.acct_line)
-        new_line.uncancel(suspension_end + relativedelta(days=1))
-        self.assertFalse(new_line.is_canceled)
-        self.assertEqual(self.acct_line.successor_contract_line_id, new_line)
-        self.assertEqual(
-            new_line.recurring_next_date,
-            suspension_end + relativedelta(days=1),
-        )
-
-    def test_cancel_uncancel_with_predecessor_has_successor(self):
-        suspension_start = self.today + relativedelta(months=6)
-        suspension_end = self.today + relativedelta(months=7)
-        start_date = self.today
-        end_date = self.today + relativedelta(months=8)
-        self.acct_line.write(
-            {
-                "date_start": start_date,
-                "recurring_next_date": start_date,
-                "date_end": end_date,
-            }
-        )
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        new_line = self.env["contract.line"].search(
-            [("predecessor_contract_line_id", "=", self.acct_line.id)]
-        )
-        new_line.cancel()
-        suspension_start = self.today + relativedelta(months=4)
-        suspension_end = self.today + relativedelta(months=5)
-        self.acct_line.stop_plan_successor(suspension_start, suspension_end, True)
-        with self.assertRaises(ValidationError):
-            new_line.uncancel(suspension_end)
-
-    def test_check_has_not_date_end_has_successor(self):
-        self.acct_line.write({"date_end": False, "is_auto_renew": False})
-        with self.assertRaises(ValidationError):
-            self.acct_line.plan_successor(
-                to_date("2016-03-01"), to_date("2016-09-01"), False
-            )
-
-    def test_check_has_not_date_end_is_auto_renew(self):
-        with self.assertRaises(ValidationError):
-            self.acct_line.write({"date_end": False, "is_auto_renew": True})
-
-    def test_check_has_successor_is_auto_renew(self):
-        with self.assertRaises(ValidationError):
-            self.acct_line.plan_successor(
-                to_date("2016-03-01"), to_date("2018-09-01"), False
-            )
-
-    def test_search_contract_line_to_renew(self):
-        self.acct_line.write({"date_end": self.today, "is_auto_renew": True})
-        line_1 = self.acct_line.copy({"date_end": self.today + relativedelta(months=1)})
-        line_2 = self.acct_line.copy({"date_end": self.today - relativedelta(months=1)})
-        line_3 = self.acct_line.copy({"date_end": self.today - relativedelta(months=2)})
-        line_4 = self.acct_line.copy({"date_end": self.today + relativedelta(months=2)})
-        to_renew = self.acct_line.search(
-            self.acct_line._contract_line_to_renew_domain()
-        )
-        self.assertEqual(set(to_renew), {self.acct_line, line_1, line_2, line_3})
-        self.acct_line.cron_renew_contract_line()
-        self.assertTrue(self.acct_line.successor_contract_line_id)
-        self.assertTrue(line_1.successor_contract_line_id)
-        self.assertTrue(line_2.successor_contract_line_id)
-        self.assertTrue(line_3.successor_contract_line_id)
-        self.assertFalse(line_4.successor_contract_line_id)
-
-    def test_renew_create_new_line(self):
-        date_start = self.today - relativedelta(months=9)
-        date_end = date_start + relativedelta(months=12) - relativedelta(days=1)
-        self.acct_line.write(
-            {
-                "is_auto_renew": True,
-                "date_start": date_start,
-                "recurring_next_date": date_start,
-                "date_end": self.today,
-            }
-        )
-        self.acct_line._onchange_is_auto_renew()
-        self.assertEqual(self.acct_line.date_end, date_end)
-        new_line = self.acct_line.renew()
-        self.assertFalse(self.acct_line.is_auto_renew)
-        self.assertTrue(new_line.is_auto_renew)
-        self.assertEqual(new_line.date_start, date_start + relativedelta(months=12))
-        self.assertEqual(new_line.date_end, date_end + relativedelta(months=12))
-
-    def test_renew_extend_original_line(self):
-        self.contract.company_id.create_new_line_at_contract_line_renew = False
-        date_start = self.today - relativedelta(months=9)
-        date_end = date_start + relativedelta(months=12) - relativedelta(days=1)
-        self.acct_line.write(
-            {
-                "is_auto_renew": True,
-                "date_start": date_start,
-                "recurring_next_date": date_start,
-                "date_end": self.today,
-            }
-        )
-        self.acct_line._onchange_is_auto_renew()
-        self.assertEqual(self.acct_line.date_end, date_end)
-        self.acct_line.renew()
-        self.assertTrue(self.acct_line.is_auto_renew)
-        self.assertEqual(self.acct_line.date_start, date_start)
-        self.assertEqual(self.acct_line.date_end, date_end + relativedelta(months=12))
-
     def test_cron_recurring_create_invoice(self):
         self.acct_line.date_start = "2018-01-01"
         self.acct_line.recurring_invoicing_type = "post-paid"
@@ -1760,7 +1157,6 @@ class TestContract(TestContractBase):
         )
         self.assertEqual(first, to_date("2018-03-01"))
         self.assertEqual(last, to_date("2018-03-15"))
-        self.acct_line.manual_renew_needed = True
 
     def test_get_period_to_invoice_monthlylastday_prepaid(self):
         self.acct_line.date_start = "2018-01-05"
@@ -1950,140 +1346,6 @@ class TestContract(TestContractBase):
         self.assertEqual(first, to_date("2020-01-05"))
         self.assertEqual(last, to_date("2020-03-15"))
 
-    def test_unlink(self):
-        with self.assertRaises(ValidationError):
-            self.acct_line.unlink()
-
-    def test_contract_line_state(self):
-        lines = self.env["contract.line"]
-        # upcoming
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today + relativedelta(months=3),
-                "recurring_next_date": self.today + relativedelta(months=3),
-                "date_end": self.today + relativedelta(months=5),
-            }
-        )
-        # in-progress
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=5),
-            }
-        )
-        # in-progress
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today,
-                "recurring_next_date": self.today,
-                "date_end": self.today + relativedelta(months=5),
-                "manual_renew_needed": True,
-            }
-        )
-        # to-renew
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today - relativedelta(months=5),
-                "recurring_next_date": self.today - relativedelta(months=5),
-                "date_end": self.today - relativedelta(months=2),
-                "manual_renew_needed": True,
-            }
-        )
-        # upcoming-close
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today - relativedelta(months=5),
-                "recurring_next_date": self.today - relativedelta(months=5),
-                "date_end": self.today + relativedelta(days=20),
-                "is_auto_renew": False,
-            }
-        )
-        # closed
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today - relativedelta(months=5),
-                "recurring_next_date": self.today - relativedelta(months=5),
-                "date_end": self.today - relativedelta(months=2),
-                "is_auto_renew": False,
-            }
-        )
-        # canceled
-        lines |= self.acct_line.copy(
-            {
-                "date_start": self.today - relativedelta(months=5),
-                "recurring_next_date": self.today - relativedelta(months=5),
-                "date_end": self.today - relativedelta(months=2),
-                "is_canceled": True,
-            }
-        )
-        # section
-        lines |= self.env["contract.line"].create(
-            {
-                "contract_id": self.contract.id,
-                "display_type": "line_section",
-                "name": "Test section",
-            }
-        )
-        states = [
-            "upcoming",
-            "in-progress",
-            "to-renew",
-            "upcoming-close",
-            "closed",
-            "canceled",
-            False,
-        ]
-        self.assertEqual(set(lines.mapped("state")), set(states))
-        # Test search method
-        lines.flush_recordset()  # Needed for computed stored fields
-        # like termination_notice_date
-        for state in states:
-            lines = self.env["contract.line"].search([("state", "=", state)])
-            self.assertTrue(lines, state)
-            self.assertTrue(state in lines.mapped("state"), state)
-            lines = self.env["contract.line"].search([("state", "!=", state)])
-            self.assertFalse(state in lines.mapped("state"), state)
-        lines = self.env["contract.line"].search([("state", "in", states)])
-        self.assertEqual(set(lines.mapped("state")), set(states))
-        lines = self.env["contract.line"].search([("state", "in", [])])
-        self.assertFalse(lines.mapped("state"))
-        with self.assertRaises(TypeError):
-            self.env["contract.line"].search([("state", "in", "upcoming")])
-        lines = self.env["contract.line"].search([("state", "not in", [])])
-        self.assertEqual(set(lines.mapped("state")), set(states))
-        lines = self.env["contract.line"].search([("state", "not in", states)])
-        self.assertFalse(lines.mapped("state"))
-        state2 = ["upcoming", "in-progress"]
-        lines = self.env["contract.line"].search([("state", "not in", state2)])
-        self.assertEqual(set(lines.mapped("state")), set(states) - set(state2))
-
-    def test_check_auto_renew_contract_line_with_successor(self):
-        """
-        A contract line with a successor can't be set to auto-renew
-        """
-        successor_contract_line = self.acct_line.copy()
-        with self.assertRaises(ValidationError):
-            self.acct_line.write(
-                {
-                    "is_auto_renew": True,
-                    "successor_contract_line_id": successor_contract_line.id,
-                }
-            )
-
-    def test_check_no_date_end_contract_line_with_successor(self):
-        """
-        A contract line with a successor must have a end date
-        """
-        successor_contract_line = self.acct_line.copy()
-        with self.assertRaises(ValidationError):
-            self.acct_line.write(
-                {
-                    "date_end": False,
-                    "successor_contract_line_id": successor_contract_line.id,
-                }
-            )
-
     def test_check_last_date_invoiced_1(self):
         """
         start end can't be before the date of last invoice
@@ -2106,49 +1368,11 @@ class TestContract(TestContractBase):
                 {"last_date_invoiced": self.acct_line.date_end + relativedelta(days=1)}
             )
 
-    def test_delay_invoiced_contract_line(self):
-        self.acct_line.write(
-            {"last_date_invoiced": self.acct_line.date_start + relativedelta(days=1)}
-        )
-        with self.assertRaises(ValidationError):
-            self.acct_line._delay(relativedelta(months=1))
-
-    def test_cancel_invoiced_contract_line(self):
-        self.acct_line.write(
-            {"last_date_invoiced": self.acct_line.date_start + relativedelta(days=1)}
-        )
-        with self.assertRaises(ValidationError):
-            self.acct_line.cancel()
-
-    def test_action_uncancel(self):
-        action = self.acct_line.action_uncancel()
-        self.assertEqual(
-            action["context"]["default_contract_line_id"], self.acct_line.id
-        )
-
-    def test_action_plan_successor(self):
-        action = self.acct_line.action_plan_successor()
-        self.assertEqual(
-            action["context"]["default_contract_line_id"], self.acct_line.id
-        )
-
-    def test_action_stop(self):
-        action = self.acct_line.action_stop()
-        self.assertEqual(
-            action["context"]["default_contract_line_id"], self.acct_line.id
-        )
-
-    def test_action_stop_plan_successor(self):
-        action = self.acct_line.action_stop_plan_successor()
-        self.assertEqual(
-            action["context"]["default_contract_line_id"], self.acct_line.id
-        )
-
     def test_purchase_get_view(self):
         purchase_tree_view = self.env.ref("contract.contract_line_supplier_tree_view")
         purchase_form_view = self.env.ref("contract.contract_line_supplier_form_view")
         view = self.acct_line.with_context(default_contract_type="purchase").get_view(
-            view_type="tree"
+            view_type="list"
         )
         self.assertEqual(view["id"], purchase_tree_view.id)
         view = self.acct_line.with_context(default_contract_type="purchase").get_view(
@@ -2221,16 +1445,9 @@ class TestContract(TestContractBase):
         self.assertFalse(section.create_invoice_visibility)
 
     def test_invoice_contract_without_lines(self):
-        self.contract.contract_line_ids.cancel()
         self.contract.contract_line_ids.unlink()
         self.assertFalse(self.contract.recurring_create_invoice())
 
-    def test_stop_at_last_date_invoiced(self):
-        self.contract.recurring_create_invoice()
-        self.assertTrue(self.acct_line.recurring_next_date)
-        self.acct_line.stop(self.acct_line.last_date_invoiced)
-        self.assertFalse(self.acct_line.recurring_next_date)
-
     def test_check_last_date_invoiced_before_next_invoice_date(self):
         with self.assertRaises(ValidationError):
             self.acct_line.write(
@@ -2242,69 +1459,6 @@ class TestContract(TestContractBase):
                 }
             )
 
-    def test_stop_and_update_recurring_invoice_date(self):
-        self.acct_line.write(
-            {
-                "date_start": "2019-01-01",
-                "date_end": "2019-12-31",
-                "recurring_next_date": "2020-01-01",
-                "recurring_invoicing_type": "post-paid",
-                "recurring_rule_type": "yearly",
-            }
-        )
-        self.acct_line.stop(to_date("2019-05-31"))
-        self.assertEqual(self.acct_line.date_end, to_date("2019-05-31"))
-        self.assertEqual(self.acct_line.recurring_next_date, to_date("2019-06-01"))
-
-    def test_action_terminate_contract(self):
-        action = self.contract.action_terminate_contract()
-        wizard = (
-            self.env[action["res_model"]]
-            .with_context(**action["context"])
-            .create(
-                {
-                    "terminate_date": "2018-03-01",
-                    "terminate_reason_id": self.terminate_reason.id,
-                    "terminate_comment": "terminate_comment",
-                }
-            )
-        )
-        self.assertEqual(wizard.contract_id, self.contract)
-        with self.assertRaises(UserError):
-            wizard.terminate_contract()
-        group_can_terminate_contract = self.env.ref("contract.can_terminate_contract")
-        group_can_terminate_contract.users |= self.env.user
-        wizard.terminate_contract()
-        self.assertTrue(self.contract.is_terminated)
-        self.assertEqual(self.contract.terminate_date, to_date("2018-03-01"))
-        self.assertEqual(self.contract.terminate_reason_id.id, self.terminate_reason.id)
-        self.assertEqual(self.contract.terminate_comment, "terminate_comment")
-        self.contract.action_cancel_contract_termination()
-        self.assertFalse(self.contract.is_terminated)
-        self.assertFalse(self.contract.terminate_reason_id)
-        self.assertFalse(self.contract.terminate_comment)
-
-    def test_terminate_date_before_last_date_invoiced(self):
-        self.contract.recurring_create_invoice()
-        self.assertEqual(self.acct_line.last_date_invoiced, to_date("2018-02-14"))
-        group_can_terminate_contract = self.env.ref("contract.can_terminate_contract")
-        group_can_terminate_contract.users |= self.env.user
-        with self.assertRaises(ValidationError):
-            self.contract._terminate_contract(
-                self.terminate_reason,
-                "terminate_comment",
-                to_date("2018-02-13"),
-            )
-        # Try terminate contract line with last_date_invoiced allowed
-        self.contract._terminate_contract(
-            self.terminate_reason,
-            "terminate_comment",
-            to_date("2018-02-13"),
-            terminate_lines_with_last_date_invoiced=True,
-        )
-        self.assertTrue(self.contract.is_terminated)
-        self.assertEqual(self.acct_line.date_end, to_date("2018-02-14"))
-
     def test_recurrency_propagation(self):
         # Existing contract
         vals = {