mirror of
https://github.com/OCA/contract.git
synced 2025-02-13 17:57:24 +02:00
2310 lines
96 KiB
Python
2310 lines
96 KiB
Python
# Copyright 2018 Tecnativa - Carlos Dauden
|
|
# Copyright 2018-2020 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 UserError, ValidationError
|
|
from odoo.tests import Form, 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,
|
|
"line_recurrence": True,
|
|
}
|
|
)
|
|
cls.contract2 = cls.env["contract.contract"].create(
|
|
{
|
|
"name": "Test Contract 2",
|
|
"partner_id": cls.partner.id,
|
|
"pricelist_id": cls.partner.property_product_pricelist.id,
|
|
"line_recurrence": True,
|
|
"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"}
|
|
)
|
|
|
|
cls.contract3 = cls.env["contract.contract"].create(
|
|
{
|
|
"name": "Test Contract 3",
|
|
"partner_id": cls.partner.id,
|
|
"pricelist_id": cls.partner.property_product_pricelist.id,
|
|
"line_recurrence": False,
|
|
"contract_type": "sale",
|
|
"recurring_interval": 1,
|
|
"recurring_rule_type": "monthly",
|
|
"date_start": "2018-02-15",
|
|
"contract_line_ids": [
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"product_id": False,
|
|
"name": "Services from #START# to #END#",
|
|
"quantity": 1,
|
|
"price_unit": 100,
|
|
},
|
|
),
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"product_id": False,
|
|
"name": "Line",
|
|
"quantity": 1,
|
|
"price_unit": 120,
|
|
},
|
|
),
|
|
],
|
|
}
|
|
)
|
|
|
|
|
|
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):
|
|
self.assertEqual(self.contract.recurring_next_date, to_date("2018-01-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, to_date("2018-02-15"))
|
|
self.inv_line = self.invoice_monthly.invoice_line_ids[0]
|
|
self.assertTrue(self.inv_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_level_recurrence(self):
|
|
self.contract3.recurring_create_invoice()
|
|
self.contract3.flush()
|
|
|
|
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_invoice_followers(self):
|
|
self.acct_line.recurring_next_date = "2018-02-23"
|
|
self.acct_line.recurring_rule_type = "daily"
|
|
self.contract.pricelist_id = False
|
|
self.contract.message_subscribe(
|
|
partner_ids=self.contract.partner_id.ids,
|
|
subtype_ids=self.env.ref(
|
|
"contract.mail_message_subtype_invoice_created"
|
|
).ids,
|
|
)
|
|
self.contract._recurring_create_invoice()
|
|
invoice_daily = self.contract._get_related_invoices()
|
|
self.assertTrue(invoice_daily)
|
|
self.assertEqual(len(invoice_daily.message_partner_ids.ids), 1)
|
|
|
|
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.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.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_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",
|
|
"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,
|
|
}
|
|
)
|
|
|
|
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), {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"
|
|
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.move.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.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.assertFalse(
|
|
contracts
|
|
- self.env["contract.contract"].search(
|
|
wizard.action_show_contract_to_invoice()["domain"]
|
|
),
|
|
)
|
|
action = wizard.create_invoice()
|
|
invoice_lines = self.env["account.move.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.move"].search(action["domain"])
|
|
self.assertFalse(invoice_lines.mapped("move_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"
|
|
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"
|
|
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.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.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"
|
|
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"
|
|
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"
|
|
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"
|
|
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
|
|
lines.flush() # Needed for computed stored fields like termination_notice_date
|
|
for state in states:
|
|
lines = self.env["contract.line"].search([("state", "=", state)])
|
|
self.assertTrue(lines, state)
|
|
self.assertTrue(state in lines.mapped("state"), state)
|
|
lines = self.env["contract.line"].search([("state", "!=", state)])
|
|
self.assertFalse(state in lines.mapped("state"), state)
|
|
lines = self.env["contract.line"].search([("state", "in", states)])
|
|
self.assertEqual(set(lines.mapped("state")), set(states))
|
|
lines = self.env["contract.line"].search([("state", "in", [])])
|
|
self.assertFalse(lines.mapped("state"))
|
|
with self.assertRaises(TypeError):
|
|
self.env["contract.line"].search([("state", "in", "upcoming")])
|
|
lines = self.env["contract.line"].search([("state", "not in", [])])
|
|
self.assertEqual(set(lines.mapped("state")), set(states))
|
|
lines = self.env["contract.line"].search([("state", "not in", states)])
|
|
self.assertFalse(lines.mapped("state"))
|
|
state2 = ["upcoming", "in-progress"]
|
|
lines = self.env["contract.line"].search([("state", "not in", state2)])
|
|
self.assertEqual(set(lines.mapped("state")), set(states) - set(state2))
|
|
|
|
def test_check_auto_renew_contract_line_with_successor(self):
|
|
"""
|
|
A contract line with a successor can't be set to auto-renew
|
|
"""
|
|
successor_contract_line = self.acct_line.copy()
|
|
with self.assertRaises(ValidationError):
|
|
self.acct_line.write(
|
|
{
|
|
"is_auto_renew": True,
|
|
"successor_contract_line_id": successor_contract_line.id,
|
|
}
|
|
)
|
|
|
|
def test_check_no_date_end_contract_line_with_successor(self):
|
|
"""
|
|
A contract line with a successor must have a end date
|
|
"""
|
|
successor_contract_line = self.acct_line.copy()
|
|
with self.assertRaises(ValidationError):
|
|
self.acct_line.write(
|
|
{
|
|
"date_end": False,
|
|
"successor_contract_line_id": successor_contract_line.id,
|
|
}
|
|
)
|
|
|
|
def test_check_last_date_invoiced_1(self):
|
|
"""
|
|
start end can't be before the date of last invoice
|
|
"""
|
|
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_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_multicompany_partner_edited(self):
|
|
"""Editing a partner with contracts in several companies works."""
|
|
company2 = self.env["res.company"].create({"name": "Company 2"})
|
|
unprivileged_user = self.env["res.users"].create(
|
|
{
|
|
"name": "unprivileged test user",
|
|
"login": "test",
|
|
"company_id": company2.id,
|
|
"company_ids": [(4, company2.id, False)],
|
|
}
|
|
)
|
|
parent_partner = self.env["res.partner"].create(
|
|
{"name": "parent partner", "is_company": True}
|
|
)
|
|
# Assume contract 2 is for company 2
|
|
self.contract2.company_id = company2
|
|
# Update the partner attached to both contracts
|
|
self.partner.with_user(unprivileged_user).with_context(
|
|
company_id=company2.id, force_company=company2.id
|
|
).write({"is_company": False, "parent_id": parent_partner.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.move"]
|
|
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"),
|
|
)
|
|
|
|
def test_recurrency_propagation(self):
|
|
# Existing contract
|
|
vals = {
|
|
"recurring_rule_type": "yearly",
|
|
"recurring_interval": 2,
|
|
"date_start": to_date("2020-01-01"),
|
|
}
|
|
vals2 = vals.copy()
|
|
vals2["line_recurrence"] = False
|
|
self.contract.write(vals2)
|
|
for field in vals:
|
|
self.assertEqual(vals[field], self.acct_line[field])
|
|
# New contract
|
|
contract_form = Form(self.env["contract.contract"])
|
|
contract_form.partner_id = self.partner
|
|
contract_form.name = "Test new contract"
|
|
contract_form.line_recurrence = False
|
|
for field in vals:
|
|
setattr(contract_form, field, vals[field])
|
|
with contract_form.contract_line_fixed_ids.new() as line_form:
|
|
line_form.product_id = self.product_1
|
|
contract2 = contract_form.save()
|
|
for field in vals:
|
|
self.assertEqual(vals[field], contract2.contract_line_ids[field])
|
|
|
|
def test_currency(self):
|
|
currency_eur = self.env.ref("base.EUR")
|
|
currency_cad = self.env.ref("base.CAD")
|
|
# Get currency from company
|
|
self.contract2.journal_id = False
|
|
self.assertEqual(
|
|
self.contract2.currency_id, self.contract2.company_id.currency_id
|
|
)
|
|
# Get currency from journal
|
|
journal = self.env["account.journal"].create(
|
|
{
|
|
"name": "Test journal CAD",
|
|
"code": "TCAD",
|
|
"type": "sale",
|
|
"currency_id": currency_cad.id,
|
|
}
|
|
)
|
|
self.contract2.journal_id = journal.id
|
|
self.assertEqual(self.contract2.currency_id, currency_cad)
|
|
# Get currency from contract pricelist
|
|
pricelist = self.env["product.pricelist"].create(
|
|
{"name": "Test pricelist", "currency_id": currency_eur.id}
|
|
)
|
|
self.contract2.pricelist_id = pricelist.id
|
|
self.contract2.contract_line_ids.automatic_price = True
|
|
self.assertEqual(self.contract2.currency_id, currency_eur)
|
|
# Get currency from partner pricelist
|
|
self.contract2.pricelist_id = False
|
|
self.contract2.partner_id.property_product_pricelist = pricelist.id
|
|
pricelist.currency_id = currency_cad.id
|
|
self.assertEqual(self.contract2.currency_id, currency_cad)
|
|
# Assign manual currency
|
|
self.contract2.manual_currency_id = currency_eur.id
|
|
self.assertEqual(self.contract2.currency_id, currency_eur)
|
|
# Assign same currency as computed one
|
|
self.contract2.currency_id = currency_cad.id
|
|
self.assertFalse(self.contract2.manual_currency_id)
|
|
|
|
def test_contract_action_preview(self):
|
|
action = self.contract.action_preview()
|
|
self.assertIn("/my/contracts/", action["url"])
|
|
self.assertIn("access_token=", action["url"])
|