mirror of
https://gitlab.com/flectra-community/partner-contact.git
synced 2024-11-14 10:12:05 +00:00
334 lines
14 KiB
Python
334 lines
14 KiB
Python
# Copyright 2016-2017 Therp BV
|
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
|
|
|
|
from datetime import date
|
|
|
|
from flectra.exceptions import ValidationError
|
|
|
|
from .test_partner_relation_common import TestPartnerRelationCommon
|
|
|
|
|
|
class TestPartnerRelation(TestPartnerRelationCommon):
|
|
def setUp(self):
|
|
super(TestPartnerRelation, self).setUp()
|
|
|
|
# Create a new relation type which will not have valid relations:
|
|
category_nobody = self.category_model.create({"name": "Nobody"})
|
|
(
|
|
self.type_nobody,
|
|
self.selection_nobody,
|
|
self.selection_nobody_inverse,
|
|
) = self._create_relation_type_selection(
|
|
{
|
|
"name": "has relation with nobody",
|
|
"name_inverse": "nobody has relation with",
|
|
"contact_type_left": "c",
|
|
"contact_type_right": "p",
|
|
"partner_category_left": category_nobody.id,
|
|
"partner_category_right": category_nobody.id,
|
|
}
|
|
)
|
|
|
|
def _get_empty_relation(self):
|
|
"""Get empty relation record for onchange tests."""
|
|
# Need English, because we will compare text
|
|
return self.relation_all_model.with_context(lang="en_US").new({})
|
|
|
|
def test_get_partner_types(self):
|
|
"""Partner types should contain at least 'c' and 'p'."""
|
|
partner_types = self.selection_model.get_partner_types()
|
|
type_codes = [ptype[0] for ptype in partner_types]
|
|
self.assertTrue("c" in type_codes)
|
|
self.assertTrue("p" in type_codes)
|
|
|
|
def test_create_with_active_id(self):
|
|
"""Test creation with this_partner_id from active_id."""
|
|
# Check wether we can create connection from company to person,
|
|
# taking the particular company from the active records:
|
|
relation = self.relation_all_model.with_context(
|
|
active_id=self.partner_02_company.id, active_ids=self.partner_02_company.ids
|
|
).create(
|
|
{
|
|
"other_partner_id": self.partner_01_person.id,
|
|
"type_selection_id": self.selection_company2person.id,
|
|
}
|
|
)
|
|
self.assertTrue(relation)
|
|
self.assertEqual(relation.this_partner_id, self.partner_02_company)
|
|
# Partner should have one relation now:
|
|
relation.invalidate_cache(None, relation.ids)
|
|
self.partner_01_person.flush()
|
|
self.assertEqual(self.partner_01_person.relation_count, 1)
|
|
# Test create without type_selection_id:
|
|
with self.assertRaises(ValidationError):
|
|
self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": self.partner_02_company.id,
|
|
"other_partner_id": self.partner_01_person.id,
|
|
}
|
|
)
|
|
|
|
def test_display_name(self):
|
|
"""Test display name"""
|
|
relation = self._create_company2person_relation()
|
|
self.assertEqual(
|
|
relation.display_name,
|
|
"%s %s %s"
|
|
% (
|
|
relation.this_partner_id.name,
|
|
relation.type_selection_id.name,
|
|
relation.other_partner_id.name,
|
|
),
|
|
)
|
|
|
|
def test_regular_write(self):
|
|
"""Test write with valid data."""
|
|
relation = self._create_company2person_relation()
|
|
relation.write({"date_start": "2014-09-01"})
|
|
self.assertEqual(relation.date_start, date(2014, 9, 1))
|
|
|
|
def test_write_incompatible_dates(self):
|
|
"""Test write with date_end before date_start."""
|
|
relation = self._create_company2person_relation()
|
|
with self.assertRaises(ValidationError):
|
|
relation.write({"date_start": "2016-09-01", "date_end": "2016-08-01"})
|
|
|
|
def test_validate_overlapping_01(self):
|
|
"""Test create overlapping with no start / end dates."""
|
|
relation = self._create_company2person_relation()
|
|
with self.assertRaises(ValidationError):
|
|
# New relation with no start / end should give error
|
|
self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": relation.this_partner_id.id,
|
|
"type_selection_id": relation.type_selection_id.id,
|
|
"other_partner_id": relation.other_partner_id.id,
|
|
}
|
|
)
|
|
|
|
def test_validate_overlapping_02(self):
|
|
"""Test create overlapping with start / end dates."""
|
|
relation = self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": self.partner_02_company.id,
|
|
"type_selection_id": self.selection_company2person.id,
|
|
"other_partner_id": self.partner_01_person.id,
|
|
"date_start": "2015-09-01",
|
|
"date_end": "2016-08-31",
|
|
}
|
|
)
|
|
# New relation with overlapping start / end should give error
|
|
with self.assertRaises(ValidationError):
|
|
self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": relation.this_partner_id.id,
|
|
"type_selection_id": relation.type_selection_id.id,
|
|
"other_partner_id": relation.other_partner_id.id,
|
|
"date_start": "2016-08-01",
|
|
"date_end": "2017-07-30",
|
|
}
|
|
)
|
|
|
|
def test_validate_overlapping_03(self):
|
|
"""Test create not overlapping."""
|
|
relation = self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": self.partner_02_company.id,
|
|
"type_selection_id": self.selection_company2person.id,
|
|
"other_partner_id": self.partner_01_person.id,
|
|
"date_start": "2015-09-01",
|
|
"date_end": "2016-08-31",
|
|
}
|
|
)
|
|
relation_another_record = self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": relation.this_partner_id.id,
|
|
"type_selection_id": relation.type_selection_id.id,
|
|
"other_partner_id": relation.other_partner_id.id,
|
|
"date_start": "2016-09-01",
|
|
"date_end": "2017-08-31",
|
|
}
|
|
)
|
|
self.assertTrue(relation_another_record)
|
|
|
|
def test_inverse_record(self):
|
|
"""Test creation of inverse record."""
|
|
relation = self._create_company2person_relation()
|
|
inverse_relation = self.relation_all_model.search(
|
|
[
|
|
("this_partner_id", "=", relation.other_partner_id.id),
|
|
("other_partner_id", "=", relation.this_partner_id.id),
|
|
]
|
|
)
|
|
self.assertEqual(len(inverse_relation), 1)
|
|
self.assertEqual(
|
|
inverse_relation.type_selection_id.name, self.selection_person2company.name
|
|
)
|
|
|
|
def test_inverse_creation(self):
|
|
"""Test creation of record through inverse selection."""
|
|
relation = self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": self.partner_01_person.id,
|
|
"type_selection_id": self.selection_person2company.id,
|
|
"other_partner_id": self.partner_02_company.id,
|
|
}
|
|
)
|
|
# Check wether display name is what we should expect:
|
|
self.assertEqual(
|
|
relation.display_name,
|
|
"%s %s %s"
|
|
% (
|
|
self.partner_01_person.name,
|
|
self.selection_person2company.name,
|
|
self.partner_02_company.name,
|
|
),
|
|
)
|
|
|
|
def test_inverse_creation_type_id(self):
|
|
"""Test creation of record through inverse selection with type_id."""
|
|
relation = self.relation_all_model.create(
|
|
{
|
|
"this_partner_id": self.partner_01_person.id,
|
|
"type_id": self.selection_person2company.type_id.id,
|
|
"is_inverse": True,
|
|
"other_partner_id": self.partner_02_company.id,
|
|
}
|
|
)
|
|
# Check wether display name is what we should expect:
|
|
self.assertEqual(
|
|
relation.display_name,
|
|
"%s %s %s"
|
|
% (
|
|
self.partner_01_person.name,
|
|
self.selection_person2company.name,
|
|
self.partner_02_company.name,
|
|
),
|
|
)
|
|
|
|
def test_unlink(self):
|
|
"""Unlinking derived relation should unlink base relation."""
|
|
# Check wether underlying record is removed when record is removed:
|
|
relation = self._create_company2person_relation()
|
|
base_model = self.env[relation.res_model]
|
|
base_relation = base_model.browse([relation.res_id])
|
|
relation.unlink()
|
|
self.assertFalse(base_relation.exists())
|
|
# Check unlinking record sets with both derived relation records
|
|
self.assertTrue(self.relation_all_model.search([]).unlink())
|
|
|
|
def test_on_change_type_selection(self):
|
|
"""Test on_change_type_selection."""
|
|
# 1. Test call with empty relation
|
|
relation_empty = self._get_empty_relation()
|
|
result = relation_empty.onchange_type_selection_id()
|
|
self.assertTrue("domain" in result)
|
|
self.assertFalse("warning" in result)
|
|
self.assertTrue("this_partner_id" in result["domain"])
|
|
self.assertFalse(result["domain"]["this_partner_id"])
|
|
self.assertTrue("other_partner_id" in result["domain"])
|
|
self.assertFalse(result["domain"]["other_partner_id"])
|
|
# 2. Test call with company 2 person relation
|
|
relation = self._create_company2person_relation()
|
|
domain = relation.onchange_type_selection_id()["domain"]
|
|
self.assertTrue(("is_company", "=", False) in domain["other_partner_id"])
|
|
# 3. Test with relation needing categories,
|
|
# take active partner from active_id:
|
|
relation_ngo_volunteer = self.relation_all_model.with_context(
|
|
active_id=self.partner_03_ngo.id
|
|
).create(
|
|
{
|
|
"type_selection_id": self.selection_ngo2volunteer.id,
|
|
"other_partner_id": self.partner_04_volunteer.id,
|
|
}
|
|
)
|
|
domain = relation_ngo_volunteer.onchange_type_selection_id()["domain"]
|
|
self.assertTrue(
|
|
("category_id", "in", [self.category_01_ngo.id])
|
|
in domain["this_partner_id"]
|
|
)
|
|
self.assertTrue(
|
|
("category_id", "in", [self.category_02_volunteer.id])
|
|
in domain["other_partner_id"]
|
|
)
|
|
# 4. Test with invalid or impossible combinations
|
|
relation_nobody = self._get_empty_relation()
|
|
relation_nobody.type_selection_id = self.selection_nobody
|
|
warning = relation_nobody.onchange_type_selection_id()["warning"]
|
|
self.assertTrue("message" in warning)
|
|
self.assertTrue("No this partner available" in warning["message"])
|
|
relation_nobody.this_partner_id = self.partner_02_company
|
|
warning = relation_nobody.onchange_type_selection_id()["warning"]
|
|
self.assertTrue("message" in warning)
|
|
self.assertTrue("incompatible" in warning["message"])
|
|
# Allow left partner and check message for other partner:
|
|
self.type_nobody.write({"partner_category_left": False})
|
|
self.type_nobody.flush()
|
|
self.selection_nobody.invalidate_cache(ids=self.selection_nobody.ids)
|
|
warning = relation_nobody.onchange_type_selection_id()["warning"]
|
|
self.assertTrue("message" in warning)
|
|
self.assertTrue("No other partner available" in warning["message"])
|
|
|
|
def test_on_change_partner_id(self):
|
|
"""Test on_change_partner_id."""
|
|
# 1. Test call with empty relation
|
|
relation_empty = self._get_empty_relation()
|
|
result = relation_empty.onchange_partner_id()
|
|
self.assertTrue("domain" in result)
|
|
self.assertFalse("warning" in result)
|
|
self.assertTrue("type_selection_id" in result["domain"])
|
|
self.assertFalse(result["domain"]["type_selection_id"])
|
|
# 2. Test call with company 2 person relation
|
|
relation = self._create_company2person_relation()
|
|
domain = relation.onchange_partner_id()["domain"]
|
|
self.assertTrue(("contact_type_this", "=", "c") in domain["type_selection_id"])
|
|
# 3. Test with invalid or impossible combinations
|
|
relation_nobody = self._get_empty_relation()
|
|
relation_nobody.this_partner_id = self.partner_02_company
|
|
relation_nobody.type_selection_id = self.selection_nobody
|
|
warning = relation_nobody.onchange_partner_id()["warning"]
|
|
self.assertTrue("message" in warning)
|
|
self.assertTrue("incompatible" in warning["message"])
|
|
|
|
def test_write(self):
|
|
"""Test write. Special attention for changing type."""
|
|
relation_company2person = self._create_company2person_relation()
|
|
company_partner = relation_company2person.this_partner_id
|
|
# First get another worker:
|
|
partner_extra_person = self.partner_model.create(
|
|
{"name": "A new worker", "is_company": False, "ref": "NW01"}
|
|
)
|
|
relation_company2person.write({"other_partner_id": partner_extra_person.id})
|
|
self.assertEqual(
|
|
relation_company2person.other_partner_id.name, partner_extra_person.name
|
|
)
|
|
# We will also change to a type going from person to company:
|
|
(
|
|
type_worker2company,
|
|
selection_worker2company,
|
|
selection_company2worker,
|
|
) = self._create_relation_type_selection(
|
|
{
|
|
"name": "works for",
|
|
"name_inverse": "has worker",
|
|
"contact_type_left": "p",
|
|
"contact_type_right": "c",
|
|
}
|
|
)
|
|
relation_company2person.write(
|
|
{
|
|
"this_partner_id": partner_extra_person.id,
|
|
"type_selection_id": selection_worker2company.id,
|
|
"other_partner_id": company_partner.id,
|
|
}
|
|
)
|
|
self.assertEqual(
|
|
relation_company2person.this_partner_id.id, partner_extra_person.id
|
|
)
|
|
self.assertEqual(
|
|
relation_company2person.type_selection_id.id, selection_worker2company.id
|
|
)
|
|
self.assertEqual(
|
|
relation_company2person.other_partner_id.id, company_partner.id
|
|
)
|