# Copyright 2018 Tecnativa - Carlos Dauden
# Copyright 2018 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).

from collections import namedtuple
from datetime import timedelta
from dateutil.relativedelta import relativedelta
from odoo import fields
from odoo.exceptions import ValidationError, UserError
from odoo.tests import common


def to_date(date):
    return fields.Date.to_date(date)


class TestContractBase(common.SavepointCase):
    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        cls.today = fields.Date.today()
        cls.pricelist = cls.env['product.pricelist'].create({
            'name': 'pricelist for contract test',
        })
        cls.partner = cls.env['res.partner'].create({
            'name': 'partner test contract',
            'property_product_pricelist': cls.pricelist.id,
        })
        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
        )
        cls.product_1.description_sale = 'Test description sale'
        cls.line_template_vals = {
            'product_id': cls.product_1.id,
            'name': 'Services from #START# to #END#',
            'quantity': 1,
            'uom_id': cls.product_1.uom_id.id,
            'price_unit': 100,
            'discount': 50,
            'recurring_rule_type': 'yearly',
            'recurring_interval': 1,
        }
        cls.section_template_vals = {
            'display_type': 'line_section',
            'name': 'Test section',
        }
        cls.template_vals = {
            'name': 'Test Contract Template',
            'contract_line_ids': [
                (0, 0, cls.section_template_vals),
                (0, 0, cls.line_template_vals),
            ],
        }
        cls.template = cls.env['contract.template'].create(
            cls.template_vals
        )
        # For being sure of the applied price
        cls.env['product.pricelist.item'].create(
            {
                'pricelist_id': cls.partner.property_product_pricelist.id,
                'product_id': cls.product_1.id,
                'compute_price': 'formula',
                'base': 'list_price',
            }
        )
        cls.contract = cls.env['contract.contract'].create(
            {
                'name': 'Test Contract',
                'partner_id': cls.partner.id,
                'pricelist_id': cls.partner.property_product_pricelist.id,
            }
        )
        cls.contract2 = cls.env['contract.contract'].create(
            {
                'name': 'Test Contract 2',
                'partner_id': cls.partner.id,
                'pricelist_id': cls.partner.property_product_pricelist.id,
                'contract_type': 'purchase',
                'contract_line_ids': [
                    (
                        0,
                        0,
                        {
                            'product_id': cls.product_1.id,
                            'name': 'Services from #START# to #END#',
                            'quantity': 1,
                            'uom_id': cls.product_1.uom_id.id,
                            'price_unit': 100,
                            'discount': 50,
                            'recurring_rule_type': 'monthly',
                            'recurring_interval': 1,
                            'date_start': '2018-02-15',
                            'recurring_next_date': '2018-02-22',
                        },
                    )
                ],
            }
        )
        cls.line_vals = {
            'contract_id': cls.contract.id,
            'product_id': cls.product_1.id,
            'name': 'Services from #START# to #END#',
            'quantity': 1,
            'uom_id': cls.product_1.uom_id.id,
            'price_unit': 100,
            'discount': 50,
            'recurring_rule_type': 'monthly',
            '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.acct_line.product_id.is_auto_renew = True
        cls.contract.company_id.create_new_line_at_contract_line_renew = True
        cls.terminate_reason = cls.env['contract.terminate.reason'].create({
            'name': 'terminate_reason'
        })


class TestContract(TestContractBase):
    def _add_template_line(self, overrides=None):
        if overrides is None:
            overrides = {}
        vals = self.line_vals.copy()
        del vals['contract_id']
        del vals['date_start']
        vals['contract_id'] = self.template.id
        vals.update(overrides)
        return self.env['contract.template.line'].create(vals)

    def test_check_discount(self):
        with self.assertRaises(ValidationError):
            self.acct_line.write({'discount': 120})

    def test_automatic_price(self):
        self.acct_line.automatic_price = True
        self.product_1.list_price = 1100
        self.assertEqual(self.acct_line.price_unit, 1100)
        # Try to write other price
        self.acct_line.price_unit = 10
        self.acct_line.refresh()
        self.assertEqual(self.acct_line.price_unit, 1100)
        # Now disable automatic price
        self.acct_line.automatic_price = False
        self.acct_line.price_unit = 10
        self.acct_line.refresh()
        self.assertEqual(self.acct_line.price_unit, 10)

    def test_contract(self):
        recurring_next_date = to_date('2018-02-15')
        self.assertAlmostEqual(self.acct_line.price_subtotal, 50.0)
        res = self.acct_line._onchange_product_id()
        self.assertIn('uom_id', res['domain'])
        self.acct_line.price_unit = 100.0
        self.contract.partner_id = self.partner.id
        self.contract.recurring_create_invoice()
        self.invoice_monthly = self.contract._get_related_invoices()
        self.assertTrue(self.invoice_monthly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.inv_line = self.invoice_monthly.invoice_line_ids[0]
        self.assertTrue(self.inv_line.invoice_line_tax_ids)
        self.assertAlmostEqual(self.inv_line.price_subtotal, 50.0)
        self.assertEqual(self.contract.user_id, self.invoice_monthly.user_id)

    def test_contract_recurring_next_date(self):
        recurring_next_date = to_date('2018-01-15')
        self.assertEqual(
            self.contract.recurring_next_date, recurring_next_date
        )
        contract_line = self.acct_line.copy(
            {'recurring_next_date': '2018-01-14'}
        )
        recurring_next_date = to_date('2018-01-14')
        self.assertEqual(
            self.contract.recurring_next_date, recurring_next_date
        )
        contract_line.cancel()
        recurring_next_date = to_date('2018-01-15')
        self.assertEqual(
            self.contract.recurring_next_date, recurring_next_date
        )

    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.contract.recurring_create_invoice()
        invoice_daily = self.contract._get_related_invoices()
        self.assertTrue(invoice_daily)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_contract_yearly_pre_paid(self):
        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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    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.contract.recurring_create_invoice()
        invoices_monthly_lastday = self.contract._get_related_invoices()
        self.assertTrue(invoices_monthly_lastday)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_contract_quarterly_pre_paid(self):
        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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_contract_quarterly_post_paid(self):
        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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_contract_semesterly_pre_paid(self):
        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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_contract_semesterly_post_paid(self):
        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.contract.recurring_create_invoice()
        invoices_weekly = self.contract._get_related_invoices()
        self.assertTrue(invoices_weekly)
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )
        self.assertEqual(self.acct_line.last_date_invoiced, last_date_invoiced)

    def test_last_invoice_post_paid(self):
        self.acct_line.date_start = '2018-01-01'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        self.assertTrue(self.acct_line.create_invoice_visibility)
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-02-01')
        )
        self.assertFalse(self.acct_line.last_date_invoiced)
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-03-01')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-01-31')
        )
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-3-16')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-02-28')
        )
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-03-15')
        )
        self.assertFalse(self.acct_line.recurring_next_date)
        self.assertFalse(self.acct_line.create_invoice_visibility)
        invoices = self.contract._get_related_invoices()
        self.contract.recurring_create_invoice()
        new_invoices = self.contract._get_related_invoices()
        self.assertEqual(
            invoices,
            new_invoices,
            "Should not create a new invoice after the last one",
        )

    def test_last_invoice_pre_paid(self):
        self.acct_line.date_start = '2018-01-01'
        self.acct_line.recurring_invoicing_type = 'pre-paid'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        self.assertTrue(self.acct_line.create_invoice_visibility)
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-01-01')
        )
        self.assertFalse(self.acct_line.last_date_invoiced)
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-02-01')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-01-31')
        )
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-02-28')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-02-28')
        )
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-03-15')
        )
        self.assertFalse(self.acct_line.recurring_next_date)
        self.assertFalse(self.acct_line.create_invoice_visibility)
        invoices = self.contract._get_related_invoices()
        self.contract.recurring_create_invoice()
        new_invoices = self.contract._get_related_invoices()
        self.assertEqual(
            invoices,
            new_invoices,
            "Should not create a new invoice after the last one",
        )

    def test_onchange_partner_id(self):
        self.contract._onchange_partner_id()
        self.assertEqual(
            self.contract.pricelist_id,
            self.contract.partner_id.property_product_pricelist,
        )

    def test_onchange_date_start(self):
        recurring_next_date = to_date('2018-01-01')
        self.acct_line.date_start = recurring_next_date
        self.acct_line._onchange_date_start()
        self.assertEqual(
            self.acct_line.recurring_next_date, recurring_next_date
        )

    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()
        self.assertEqual(
            self.acct_line.uom_id, self.acct_line.product_id.uom_id
        )

    def test_onchange_product_id(self):
        line = self.env['contract.line'].new()
        res = line._onchange_product_id()
        self.assertFalse(res['domain']['uom_id'])

    def test_no_pricelist(self):
        self.contract.pricelist_id = False
        self.acct_line.quantity = 2
        self.assertAlmostEqual(self.acct_line.price_subtotal, 100.0)

    def test_check_journal(self):
        journal = self.env['account.journal'].search([('type', '=', 'sale')])
        journal.write({'type': 'general'})
        with self.assertRaises(ValidationError):
            self.contract.recurring_create_invoice()

    def test_check_date_end(self):
        with self.assertRaises(ValidationError):
            self.acct_line.date_end = '2015-12-31'

    def test_check_recurring_next_date_start_date(self):
        with self.assertRaises(ValidationError):
            self.acct_line.write(
                {
                    'date_start': '2018-01-01',
                    'recurring_next_date': '2017-01-01',
                }
            )

    def test_onchange_contract_template_id(self):
        """It should change the contract values to match the template."""
        self.contract.contract_template_id = False
        self.contract._onchange_contract_template_id()
        self.contract.contract_template_id = self.template
        self.contract._onchange_contract_template_id()
        res = {
            'contract_line_ids': [
                (
                    0,
                    0,
                    {
                        'display_type': 'line_section',
                        'name': 'Test section',
                    }
                ),
                (
                    0,
                    0,
                    {
                        'product_id': self.product_1.id,
                        'name': 'Services from #START# to #END#',
                        'quantity': 1,
                        'uom_id': self.product_1.uom_id.id,
                        'price_unit': 100,
                        'discount': 50,
                        'recurring_rule_type': 'yearly',
                        'recurring_interval': 1,
                    },
                )
            ]
        }
        del self.template_vals['name']
        self.assertDictEqual(res, self.template_vals)

    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

        self.assertFalse(
            self.contract.contract_line_ids,
            'Recurring lines were not removed.',
        )
        self.contract.contract_template_id = self.template
        self.contract._onchange_contract_template_id()
        self.assertEqual(len(self.contract.contract_line_ids), 2)
        for index, vals in [
            (0, self.section_template_vals),
            (1, self.line_template_vals)
        ]:
            contract_line = self.contract.contract_line_ids[index]
            for key, value in vals.items():
                test_value = contract_line[key]
                try:
                    test_value = test_value.id
                except AttributeError:
                    pass
                self.assertEqual(test_value, value)

    def test_send_mail_contract(self):
        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.type = 'purchase'
        self.contract._onchange_contract_type()
        self.assertFalse(
            any(
                self.contract.contract_line_ids.mapped(
                    'automatic_price'
                )
            )
        )

    def test_contract_onchange_product_id_domain_blank(self):
        """It should return a blank UoM domain when no product."""
        line = self.env['contract.template.line'].new()
        res = line._onchange_product_id()
        self.assertFalse(res['domain']['uom_id'])

    def test_contract_onchange_product_id_domain(self):
        """It should return UoM category domain."""
        line = self._add_template_line()
        res = line._onchange_product_id()
        self.assertEqual(
            res['domain']['uom_id'][0],
            ('category_id', '=', self.product_1.uom_id.category_id.id),
        )

    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.assertEqual(
            line.name, line.product_id.get_product_multiline_description_sale()
        )

    def test_contract_count(self):
        """It should return sale contract count."""
        sale_count = self.partner.sale_contract_count + 2
        self.contract.copy()
        self.contract.copy()
        purchase_count = self.partner.purchase_contract_count + 1
        self.contract2.copy()
        self.partner.refresh()
        self.assertEqual(self.partner.sale_contract_count, sale_count)
        self.assertEqual(self.partner.purchase_contract_count, purchase_count)

    def test_same_date_start_and_date_end(self):
        """It should create one invoice with same start and end date."""
        self.acct_line.write(
            {
                'date_start': self.today,
                'date_end': self.today,
                'recurring_next_date': self.today,
            }
        )
        self.contract._compute_recurring_next_date()
        init_count = len(self.contract._get_related_invoices())
        self.contract.recurring_create_invoice()
        last_count = len(self.contract._get_related_invoices())
        self.assertEqual(last_count, init_count + 1)
        self.contract.recurring_create_invoice()
        last_count = len(self.contract._get_related_invoices())
        self.assertEqual(last_count, init_count + 1)

    def test_act_show_contract(self):
        show_contract = self.partner.with_context(
            contract_type='sale'
        ).act_show_contract()
        self.assertDictContainsSubset(
            {
                'name': 'Customer Contracts',
                'type': 'ir.actions.act_window',
                'view_type': 'form',
                'res_model': 'contract.contract',
                'xml_id': 'contract.action_customer_contract',
            },
            show_contract,
            'There was an error and the view couldn\'t be opened.',
        )

    def test_get_default_recurring_invoicing_offset(self):
        clm = self.env['contract.line']
        self.assertEqual(
            clm._get_default_recurring_invoicing_offset(
                "pre-paid", "monthly"
            ),
            0
        )
        self.assertEqual(
            clm._get_default_recurring_invoicing_offset(
                "post-paid", "monthly"
            ),
            1
        )
        self.assertEqual(
            clm._get_default_recurring_invoicing_offset(
                "pre-paid", "monthlylastday"
            ),
            0
        )
        self.assertEqual(
            clm._get_default_recurring_invoicing_offset(
                "post-paid", "monthlylastday"
            ),
            0
        )

    def test_get_next_invoice_date(self):
        """Test different combination to compute recurring_next_date
        Combination format
        {
            'recurring_next_date': (      # date
                date_start,               # date
                recurring_invoicing_type, # ('pre-paid','post-paid',)
                recurring_rule_type,      # ('daily', 'weekly', 'monthly',
                                          #  'monthlylastday', 'yearly'),
                recurring_interval,       # integer
                max_date_end,             # date
            ),
        }
        """

        def error_message(
            date_start,
            recurring_invoicing_type,
            recurring_invoicing_offset,
            recurring_rule_type,
            recurring_interval,
            max_date_end,
        ):
            return (
                "Error in %s-%d every %d %s case, "
                "start with %s (max_date_end=%s)" % (
                    recurring_invoicing_type,
                    recurring_invoicing_offset,
                    recurring_interval,
                    recurring_rule_type,
                    date_start,
                    max_date_end,
                )
            )

        combinations = [
            (
                to_date('2018-01-01'),
                (to_date('2018-01-01'), 'pre-paid', 0, 'monthly', 1,
                 False),
            ),
            (
                to_date('2018-01-01'),
                (to_date('2018-01-01'), 'pre-paid', 0, 'monthly', 1,
                 to_date('2018-01-15')),
            ),
            (
                False,
                (to_date('2018-01-16'), 'pre-paid', 0, 'monthly', 1,
                 to_date('2018-01-15')),
            ),
            (
                to_date('2018-01-01'),
                (to_date('2018-01-01'), 'pre-paid', 0, 'monthly', 2,
                 False),
            ),
            (
                to_date('2018-02-01'),
                (to_date('2018-01-01'), 'post-paid', 1, 'monthly', 1,
                 False),
            ),
            (
                to_date('2018-01-16'),
                (to_date('2018-01-01'), 'post-paid', 1, 'monthly', 1,
                 to_date('2018-01-15')),
            ),
            (
                False,
                (to_date('2018-01-16'), 'post-paid', 1, 'monthly', 1,
                 to_date('2018-01-15')),
            ),
            (
                to_date('2018-03-01'),
                (to_date('2018-01-01'), 'post-paid', 1, 'monthly', 2,
                 False),
            ),
            (
                to_date('2018-01-31'),
                (to_date('2018-01-05'), 'post-paid', 0, 'monthlylastday', 1,
                 False),
            ),
            (
                to_date('2018-01-06'),
                (to_date('2018-01-06'), 'pre-paid', 0, 'monthlylastday', 1,
                 False),
            ),
            (
                to_date('2018-02-28'),
                (to_date('2018-01-05'), 'post-paid', 0, 'monthlylastday', 2,
                 False),
            ),
            (
                to_date('2018-01-05'),
                (to_date('2018-01-05'), 'pre-paid', 0, 'monthlylastday', 2,
                 False),
            ),
            (
                to_date('2018-01-05'),
                (to_date('2018-01-05'), 'pre-paid', 0, 'yearly', 1,
                 False),
            ),
            (
                to_date('2019-01-05'),
                (to_date('2018-01-05'), 'post-paid', 1, 'yearly', 1,
                 False),
            ),
        ]
        contract_line_env = self.env['contract.line']
        for recurring_next_date, combination in combinations:
            self.assertEqual(
                recurring_next_date,
                contract_line_env.get_next_invoice_date(
                    *combination
                ),
                error_message(*combination),
            )

    def test_next_invoicing_period(self):
        """Test different combination for next invoicing period
        {
            (
                'recurring_next_date',    # date
                'next_period_date_start', # date
                'next_period_date_end'    # date
                ): (
                date_start,               # date
                date_end,                 # date
                last_date_invoiced,       # date
                recurring_next_date,      # date
                recurring_invoicing_type, # ('pre-paid','post-paid',)
                recurring_rule_type,      # ('daily', 'weekly', 'monthly',
                                          #  'monthlylastday', 'yearly'),
                recurring_interval,       # integer
                max_date_end,             # date
            ),
        }
        """

        def _update_contract_line(
            case,
            date_start,
            date_end,
            last_date_invoiced,
            recurring_next_date,
            recurring_invoicing_type,
            recurring_rule_type,
            recurring_interval,
            max_date_end,
        ):
            self.acct_line.write(
                {
                    'date_start': date_start,
                    'date_end': date_end,
                    'last_date_invoiced': last_date_invoiced,
                    'recurring_next_date': recurring_next_date,
                    'recurring_invoicing_type': recurring_invoicing_type,
                    'recurring_rule_type': recurring_rule_type,
                    'recurring_interval': recurring_interval,
                    'max_date_end': max_date_end,
                }
            )

        def _get_result():
            return Result(
                recurring_next_date=self.acct_line.recurring_next_date,
                next_period_date_start=self.acct_line.next_period_date_start,
                next_period_date_end=self.acct_line.next_period_date_end,
            )

        def _error_message(
            case,
            date_start,
            date_end,
            last_date_invoiced,
            recurring_next_date,
            recurring_invoicing_type,
            recurring_rule_type,
            recurring_interval,
            max_date_end,
        ):
            return (
                "Error in case %s:"
                "date_start: %s, "
                "date_end: %s, "
                "last_date_invoiced: %s, "
                "recurring_next_date: %s, "
                "recurring_invoicing_type: %s, "
                "recurring_rule_type: %s, "
                "recurring_interval: %s, "
                "max_date_end: %s, "
            ) % (
                case,
                date_start,
                date_end,
                last_date_invoiced,
                recurring_next_date,
                recurring_invoicing_type,
                recurring_rule_type,
                recurring_interval,
                max_date_end,
            )

        Result = namedtuple(
            'Result',
            [
                'recurring_next_date',
                'next_period_date_start',
                'next_period_date_end',
            ],
        )
        Combination = namedtuple(
            'Combination',
            [
                'case',
                'date_start',
                'date_end',
                'last_date_invoiced',
                'recurring_next_date',
                'recurring_invoicing_type',
                'recurring_rule_type',
                'recurring_interval',
                'max_date_end',
            ],
        )
        combinations = {
            Result(
                recurring_next_date=to_date('2019-01-01'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-31'),
            ): Combination(
                case="1",
                date_start='2019-01-01',
                date_end=False,
                last_date_invoiced=False,
                recurring_next_date='2019-01-01',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-01'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-15'),
            ): Combination(
                case="2",
                date_start='2019-01-01',
                date_end='2019-01-15',
                last_date_invoiced=False,
                recurring_next_date='2019-01-01',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-05'),
                next_period_date_start=to_date('2019-01-05'),
                next_period_date_end=to_date('2019-01-15'),
            ): Combination(
                case="3",
                date_start='2019-01-05',
                date_end='2019-01-15',
                last_date_invoiced=False,
                recurring_next_date='2019-01-05',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-05'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-15'),
            ): Combination(
                case="4",
                date_start='2019-01-01',
                date_end='2019-01-15',
                last_date_invoiced=False,
                recurring_next_date='2019-01-05',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-02-01'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-31'),
            ): Combination(
                case="5",
                date_start='2019-01-01',
                date_end=False,
                last_date_invoiced=False,
                recurring_next_date='2019-02-01',
                recurring_invoicing_type='post-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-02-01'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-15'),
            ): Combination(
                case="6",
                date_start='2019-01-01',
                date_end='2019-01-15',
                last_date_invoiced=False,
                recurring_next_date='2019-02-01',
                recurring_invoicing_type='post-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-02-01'),
                next_period_date_start=to_date('2019-01-05'),
                next_period_date_end=to_date('2019-01-31'),
            ): Combination(
                case="7",
                date_start='2019-01-05',
                date_end=False,
                last_date_invoiced=False,
                recurring_next_date='2019-02-01',
                recurring_invoicing_type='post-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-05'),
                next_period_date_start=to_date('2019-01-01'),
                next_period_date_end=to_date('2019-01-15'),
            ): Combination(
                case="8",
                date_start='2019-01-01',
                date_end='2019-01-15',
                last_date_invoiced=False,
                recurring_next_date='2019-01-05',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-01'),
                next_period_date_start=to_date('2018-12-16'),
                next_period_date_end=to_date('2019-01-31'),
            ): Combination(
                case="9",
                date_start='2018-01-01',
                date_end='2020-01-15',
                last_date_invoiced='2018-12-15',
                recurring_next_date='2019-01-01',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2019-01-01'),
                next_period_date_start=to_date('2018-12-16'),
                next_period_date_end=to_date('2018-12-31'),
            ): Combination(
                case="10",
                date_start='2018-01-01',
                date_end='2020-01-15',
                last_date_invoiced='2018-12-15',
                recurring_next_date='2019-01-01',
                recurring_invoicing_type='post-paid',
                recurring_rule_type='monthly',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2018-12-31'),
                next_period_date_start=to_date('2018-12-16'),
                next_period_date_end=to_date('2018-12-31'),
            ): Combination(
                case="11",
                date_start='2018-01-01',
                date_end='2020-01-15',
                last_date_invoiced='2018-12-15',
                recurring_next_date='2018-12-31',
                recurring_invoicing_type='post-paid',
                recurring_rule_type='monthlylastday',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2018-12-16'),
                next_period_date_start=to_date('2018-12-16'),
                next_period_date_end=to_date('2018-12-31'),
            ): Combination(
                case="12",
                date_start='2018-01-01',
                date_end='2020-01-15',
                last_date_invoiced='2018-12-15',
                recurring_next_date='2018-12-16',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthlylastday',
                recurring_interval=1,
                max_date_end=False,
            ),
            Result(
                recurring_next_date=to_date('2018-01-05'),
                next_period_date_start=to_date('2018-01-05'),
                next_period_date_end=to_date('2018-03-31'),
            ): Combination(
                case="12",
                date_start='2018-01-05',
                date_end='2020-01-15',
                last_date_invoiced=False,
                recurring_next_date='2018-01-05',
                recurring_invoicing_type='pre-paid',
                recurring_rule_type='monthlylastday',
                recurring_interval=3,
                max_date_end=False,
            ),
        }
        for result, combination in combinations.items():
            _update_contract_line(*combination)
            self.assertEqual(
                result, _get_result(), _error_message(*combination)
            )

    def test_recurring_next_date(self):
        """recurring next date for a contract is the min for all lines"""
        self.contract.recurring_create_invoice()
        self.assertEqual(
            self.contract.recurring_next_date,
            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), set((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'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        contracts = self.contract2
        for i in range(10):
            contracts |= self.contract.copy()
        self.env['contract.contract'].cron_recurring_create_invoice()
        invoice_lines = self.env['account.invoice.line'].search(
            [('contract_line_id', 'in',
              contracts.mapped('contract_line_ids').ids)]
        )
        self.assertEqual(
            len(contracts.mapped('contract_line_ids')),
            len(invoice_lines),
        )

    def test_contract_manually_create_invoice(self):
        self.acct_line.date_start = '2018-01-01'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        self.contract2.unlink()
        contracts = self.contract
        for i in range(10):
            contracts |= self.contract.copy()
        wizard = self.env['contract.manually.create.invoice'].create({
            'invoice_date': self.today
        })
        wizard.action_show_contract_to_invoice()
        contract_to_invoice_count = wizard.contract_to_invoice_count
        self.assertEqual(
            contracts,
            self.env['contract.contract'].search(
                wizard.action_show_contract_to_invoice()['domain']
            ),
        )
        action = wizard.create_invoice()
        invoice_lines = self.env['account.invoice.line'].search(
            [('contract_line_id', 'in',
              contracts.mapped('contract_line_ids').ids)]
        )
        self.assertEqual(
            len(contracts.mapped('contract_line_ids')),
            len(invoice_lines),
        )
        invoices = self.env['account.invoice'].search(action['domain'])
        self.assertEqual(invoice_lines.mapped('invoice_id'), invoices)
        self.assertEqual(len(invoices), contract_to_invoice_count)

    def test_get_period_to_invoice_monthlylastday_postpaid(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.recurring_rule_type = 'monthlylastday'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2018-01-31'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-01'))
        self.assertEqual(last, to_date('2018-02-28'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        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'
        self.acct_line.recurring_invoicing_type = 'pre-paid'
        self.acct_line.recurring_rule_type = 'monthlylastday'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2018-01-31'))
        self.assertEqual(recurring_next_date, to_date('2018-01-05'))
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-01-05')
        )
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-01'))
        self.assertEqual(last, to_date('2018-02-28'))
        self.assertEqual(recurring_next_date, to_date('2018-02-01'))
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-02-01')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-01-31')
        )
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-03-01'))
        self.assertEqual(last, to_date('2018-03-15'))
        self.assertEqual(recurring_next_date, to_date('2018-03-01'))
        self.assertEqual(
            self.acct_line.recurring_next_date, to_date('2018-03-01')
        )
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-02-28')
        )
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertFalse(first)
        self.assertFalse(last)
        self.assertFalse(recurring_next_date)
        self.assertFalse(self.acct_line.recurring_next_date)
        self.assertEqual(
            self.acct_line.last_date_invoiced, to_date('2018-03-15')
        )

    def test_get_period_to_invoice_monthly_pre_paid_2(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'pre-paid'
        self.acct_line.recurring_rule_type = 'monthly'
        self.acct_line.date_end = '2018-08-15'
        self.acct_line._onchange_date_start()
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-03-04'))
        self.acct_line.recurring_next_date = '2018-06-05'
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-07-04'))

    def test_get_period_to_invoice_monthly_post_paid_2(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.recurring_rule_type = 'monthly'
        self.acct_line.date_end = '2018-08-15'
        self.acct_line._onchange_date_start()
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-03-04'))
        self.acct_line.recurring_next_date = '2018-06-05'
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-06-04'))

    def test_get_period_to_invoice_monthly_post_paid(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.recurring_rule_type = 'monthly'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2018-02-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-03-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-03-05'))
        self.assertEqual(last, to_date('2018-03-15'))

    def test_get_period_to_invoice_monthly_pre_paid(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'pre-paid'
        self.acct_line.recurring_rule_type = 'monthly'
        self.acct_line.date_end = '2018-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2018-02-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-02-05'))
        self.assertEqual(last, to_date('2018-03-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-03-05'))
        self.assertEqual(last, to_date('2018-03-15'))

    def test_get_period_to_invoice_yearly_post_paid(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'post-paid'
        self.acct_line.recurring_rule_type = 'yearly'
        self.acct_line.date_end = '2020-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2019-01-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2019-01-05'))
        self.assertEqual(last, to_date('2020-01-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2020-01-05'))
        self.assertEqual(last, to_date('2020-03-15'))

    def test_get_period_to_invoice_yearly_pre_paid(self):
        self.acct_line.date_start = '2018-01-05'
        self.acct_line.recurring_invoicing_type = 'pre-paid'
        self.acct_line.recurring_rule_type = 'yearly'
        self.acct_line.date_end = '2020-03-15'
        self.acct_line._onchange_date_start()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2018-01-05'))
        self.assertEqual(last, to_date('2019-01-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        self.assertEqual(first, to_date('2019-01-05'))
        self.assertEqual(last, to_date('2020-01-04'))
        self.contract.recurring_create_invoice()
        first, last, recurring_next_date = \
            self.acct_line._get_period_to_invoice(
                self.acct_line.last_date_invoiced,
                self.acct_line.recurring_next_date,
            )
        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
        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
        """
        with self.assertRaises(ValidationError):
            self.acct_line.write(
                {
                    'last_date_invoiced': self.acct_line.date_start
                    - relativedelta(days=1)
                }
            )

    def test_check_last_date_invoiced_2(self):
        """
        start date can't be after the date of last invoice
        """
        self.acct_line.write({'date_end': self.today})
        with self.assertRaises(ValidationError):
            self.acct_line.write(
                {
                    'last_date_invoiced': self.acct_line.date_end
                    + relativedelta(days=1)
                }
            )

    def test_init_last_date_invoiced(self):
        self.acct_line.write(
            {'date_start': '2019-01-01', 'recurring_next_date': '2019-03-01'}
        )
        line_monthlylastday = self.acct_line.copy(
            {
                'recurring_rule_type': 'monthlylastday',
                'recurring_next_date': '2019-03-31',
            }
        )
        line_prepaid = self.acct_line.copy(
            {
                'recurring_invoicing_type': 'pre-paid',
                'recurring_rule_type': 'monthly',
            }
        )
        line_postpaid = self.acct_line.copy(
            {
                'recurring_invoicing_type': 'post-paid',
                'recurring_rule_type': 'monthly',
            }
        )
        lines = line_monthlylastday | line_prepaid | line_postpaid
        lines.write({'last_date_invoiced': False})
        self.assertFalse(any(lines.mapped('last_date_invoiced')))
        lines._init_last_date_invoiced()
        self.assertEqual(
            line_monthlylastday.last_date_invoiced, to_date("2019-02-28")
        )
        self.assertEqual(
            line_prepaid.last_date_invoiced, to_date("2019-02-28")
        )
        self.assertEqual(
            line_postpaid.last_date_invoiced, to_date("2019-01-31")
        )

    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_fields_view_get(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'
        ).fields_view_get(view_type='tree')
        self.assertEqual(view['view_id'], purchase_tree_view.id)
        view = self.acct_line.with_context(
            default_contract_type='purchase'
        ).fields_view_get(view_type='form')
        self.assertEqual(view['view_id'], purchase_form_view.id)

    def test_sale_fields_view_get(self):
        sale_form_view = self.env.ref(
            'contract.contract_line_customer_form_view'
        )
        view = self.acct_line.with_context(
            default_contract_type='sale'
        ).fields_view_get(view_type='form')
        self.assertEqual(view['view_id'], sale_form_view.id)

    def test_contract_count_invoice(self):
        self.contract.recurring_create_invoice()
        self.contract.recurring_create_invoice()
        self.contract.recurring_create_invoice()
        self.contract._compute_invoice_count()
        self.assertEqual(self.contract.invoice_count, 3)

    def test_contract_count_invoice_2(self):
        invoices = self.env['account.invoice']
        invoices |= self.contract.recurring_create_invoice()
        invoices |= self.contract.recurring_create_invoice()
        invoices |= self.contract.recurring_create_invoice()
        action = self.contract.action_show_invoices()
        self.assertEqual(set(action['domain'][0][2]), set(invoices.ids))

    def test_compute_create_invoice_visibility(self):
        self.assertTrue(self.contract.create_invoice_visibility)
        self.acct_line.write(
            {
                'date_start': '2018-01-01',
                'date_end': '2018-12-31',
                'last_date_invoiced': '2018-12-31',
                'recurring_next_date': False,
            }
        )
        self.assertFalse(self.acct_line.create_invoice_visibility)
        self.assertFalse(self.contract.create_invoice_visibility)
        section = self.env['contract.line'].create({
            "contract_id": self.contract.id,
            "display_type": "line_section",
            "name": "Test section",
        })
        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({
                'date_start': '2019-01-01',
                'date_end': '2019-12-01',
                'recurring_next_date': '2019-01-01',
                'last_date_invoiced': '2019-06-01',
            })

    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'),
            )
