296 lines
10 KiB
Python
296 lines
10 KiB
Python
# This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
# this repository contains the full copyright notices and license terms.
|
|
import sys
|
|
import unittest
|
|
|
|
from trytond import backend
|
|
from trytond.pool import Pool
|
|
from trytond.tests.test_tryton import ModuleTestCase, with_transaction
|
|
from trytond.transaction import Transaction
|
|
|
|
|
|
class TestCase(ModuleTestCase):
|
|
'Test Party relationship module'
|
|
module = 'party_relationship'
|
|
|
|
@with_transaction()
|
|
def test_reverse_relationship(self):
|
|
'Test reverse relationship'
|
|
pool = Pool()
|
|
Party = pool.get('party.party')
|
|
RelationType = pool.get('party.relation.type')
|
|
Relation = pool.get('party.relation')
|
|
|
|
employee_of, = RelationType.create([{
|
|
'name': 'Employee of',
|
|
}])
|
|
works_for, = RelationType.create([{
|
|
'name': 'Works for',
|
|
'reverse': employee_of.id,
|
|
}])
|
|
RelationType.write([employee_of], {
|
|
'reverse': works_for.id,
|
|
})
|
|
|
|
company, employee = Party.create([{
|
|
'name': 'Company',
|
|
}, {
|
|
'name': 'Employee',
|
|
}])
|
|
|
|
Relation.create([{
|
|
'from_': company.id,
|
|
'to': employee.id,
|
|
'type': employee_of.id
|
|
}])
|
|
company_relation, = company.relations
|
|
employee_relation, = employee.relations
|
|
self.assertEqual(company_relation.type, employee_of)
|
|
self.assertEqual(company_relation.to, employee)
|
|
self.assertEqual(employee_relation.type, works_for)
|
|
self.assertEqual(employee_relation.to, company)
|
|
|
|
@with_transaction()
|
|
def test_without_reverse_relationship(self):
|
|
'Test without reverse relationship'
|
|
pool = Pool()
|
|
Party = pool.get('party.party')
|
|
RelationType = pool.get('party.relation.type')
|
|
Relation = pool.get('party.relation')
|
|
|
|
employee_of, = RelationType.create([{
|
|
'name': 'Employee of',
|
|
}])
|
|
works_for, = RelationType.create([{
|
|
'name': 'Works for',
|
|
}])
|
|
|
|
company, employee = Party.create([{
|
|
'name': 'Company',
|
|
}, {
|
|
'name': 'Employee',
|
|
}])
|
|
|
|
Relation.create([{
|
|
'from_': company.id,
|
|
'to': employee.id,
|
|
'type': employee_of.id
|
|
}])
|
|
company_relation, = company.relations
|
|
self.assertEqual(len(employee.relations), 0)
|
|
self.assertEqual(company_relation.type, employee_of)
|
|
self.assertEqual(company_relation.to, employee)
|
|
|
|
@with_transaction()
|
|
def test_relation_all(self):
|
|
'Test relation all'
|
|
pool = Pool()
|
|
Party = pool.get('party.party')
|
|
RelationType = pool.get('party.relation.type')
|
|
RelationAll = pool.get('party.relation.all')
|
|
|
|
relation_type, reverse_relation_type = RelationType.create([{
|
|
'name': 'Relation',
|
|
}, {
|
|
'name': 'Reverse',
|
|
}])
|
|
relation_type.reverse = reverse_relation_type
|
|
relation_type.save()
|
|
reverse_relation_type.reverse = relation_type
|
|
reverse_relation_type.save()
|
|
|
|
party1, party2, party3 = Party.create([{
|
|
'name': 'Party 1',
|
|
}, {
|
|
'name': 'Party 2',
|
|
}, {
|
|
'name': 'Party 3',
|
|
}])
|
|
|
|
relation, = RelationAll.create([{
|
|
'from_': party1.id,
|
|
'to': party2.id,
|
|
'type': relation_type.id,
|
|
}])
|
|
self.assertFalse(relation.id % 2)
|
|
reverse_relation, = RelationAll.search([
|
|
('id', '!=', relation.id),
|
|
])
|
|
self.assertTrue(reverse_relation.id % 2)
|
|
self.assertEqual(relation.reverse_id, reverse_relation.id)
|
|
self.assertEqual(reverse_relation.from_, party2)
|
|
self.assertEqual(reverse_relation.to, party1)
|
|
|
|
reverse_relation.from_ = party3
|
|
reverse_relation.save()
|
|
relation.save() # clear cache
|
|
self.assertEqual(reverse_relation.from_, party3)
|
|
self.assertEqual(reverse_relation.to, party1)
|
|
self.assertEqual(relation.from_, party1)
|
|
self.assertEqual(relation.to, party3)
|
|
|
|
reverse_relation.type = reverse_relation_type
|
|
reverse_relation.save()
|
|
self.assertEqual(reverse_relation.from_, party3)
|
|
self.assertEqual(reverse_relation.to, party1)
|
|
self.assertEqual(reverse_relation.type, reverse_relation_type)
|
|
self.assertEqual(relation.from_, party1)
|
|
self.assertEqual(relation.to, party3)
|
|
self.assertEqual(relation.type, relation_type)
|
|
|
|
relation.type = relation_type
|
|
relation.save()
|
|
self.assertEqual(reverse_relation.from_, party3)
|
|
self.assertEqual(reverse_relation.to, party1)
|
|
self.assertEqual(reverse_relation.type, reverse_relation_type)
|
|
self.assertEqual(relation.from_, party1)
|
|
self.assertEqual(relation.to, party3)
|
|
self.assertEqual(relation.type, relation_type)
|
|
|
|
reverse_relation.to = party2
|
|
reverse_relation.save()
|
|
relation.save() # clear cache
|
|
self.assertEqual(reverse_relation.from_, party3)
|
|
self.assertEqual(reverse_relation.to, party2)
|
|
self.assertEqual(relation.from_, party2)
|
|
self.assertEqual(relation.to, party3)
|
|
|
|
reverse_relation.from_ = party2
|
|
reverse_relation.to = party1
|
|
reverse_relation.save()
|
|
relation.save() # clear cache
|
|
self.assertEqual(reverse_relation.from_, party2)
|
|
self.assertEqual(reverse_relation.to, party1)
|
|
self.assertEqual(relation.from_, party1)
|
|
self.assertEqual(relation.to, party2)
|
|
|
|
relation.from_ = party2
|
|
relation.to = party1
|
|
relation.save()
|
|
reverse_relation.save() # clear cache
|
|
self.assertEqual(relation.from_, party2)
|
|
self.assertEqual(relation.to, party1)
|
|
self.assertEqual(reverse_relation.from_, party1)
|
|
self.assertEqual(reverse_relation.to, party2)
|
|
|
|
RelationAll.delete([reverse_relation])
|
|
self.assertEqual(RelationAll.search([]), [])
|
|
|
|
@unittest.skipIf(
|
|
backend.name == 'sqlite' and sys.version_info < (3, 6),
|
|
"Executing distance query prevents complete rollback")
|
|
@with_transaction()
|
|
def test_party_distance(self):
|
|
"Test party distance"
|
|
pool = Pool()
|
|
Party = pool.get('party.party')
|
|
RelationType = pool.get('party.relation.type')
|
|
Relation = pool.get('party.relation')
|
|
|
|
usages = RelationType.usages.selection
|
|
self.addCleanup(setattr, RelationType.usages, 'selection', usages)
|
|
RelationType.usages.selection = usages + [('test', "Test")]
|
|
|
|
relation, reverse = RelationType.create([{
|
|
'name': 'Relation',
|
|
}, {
|
|
'name': 'Reverse',
|
|
}])
|
|
relation.reverse = reverse
|
|
relation.save()
|
|
reverse.reverse = relation
|
|
reverse.save()
|
|
|
|
A, B, C, D = Party.create([{
|
|
'name': 'A',
|
|
}, {
|
|
'name': 'B',
|
|
}, {
|
|
'name': 'C',
|
|
}, {
|
|
'name': 'D'
|
|
}])
|
|
Relation.create([{
|
|
'from_': A.id,
|
|
'to': C.id,
|
|
'type': relation.id,
|
|
}, {
|
|
'from_': C.id,
|
|
'to': D.id,
|
|
'type': relation.id,
|
|
}])
|
|
|
|
parties = Party.search([])
|
|
self.assertEqual([p.distance for p in parties], [None] * 4)
|
|
|
|
with Transaction().set_context(related_party=A.id):
|
|
parties = Party.search([])
|
|
self.assertEqual(
|
|
[(p.name, p.distance) for p in parties],
|
|
[('A', 0), ('C', 1), ('D', 2), ('B', None)])
|
|
|
|
another_relation, = RelationType.create([{
|
|
'name': 'Another Relation',
|
|
'usages': ['test'],
|
|
}])
|
|
Relation.create([{
|
|
'from_': A.id,
|
|
'to': B.id,
|
|
'type': another_relation.id,
|
|
}])
|
|
|
|
with Transaction().set_context(
|
|
related_party=A.id, relation_usages=['test']):
|
|
parties = Party.search([])
|
|
self.assertEqual(
|
|
[(p.name, p.distance) for p in parties],
|
|
[('A', 0), ('B', 1), ('C', None), ('D', None)])
|
|
|
|
with Transaction().set_context(related_party=A.id):
|
|
parties = Party.search([])
|
|
self.assertEqual(
|
|
[(p.name, p.distance) for p in parties],
|
|
[('A', 0), ('B', 1), ('C', 1), ('D', 2)])
|
|
|
|
@with_transaction()
|
|
def test_contact_mechanism_distance(self):
|
|
"Test relation distance"
|
|
pool = Pool()
|
|
Party = pool.get('party.party')
|
|
ContactMechanism = pool.get('party.contact_mechanism')
|
|
RelationType = pool.get('party.relation.type')
|
|
Relation = pool.get('party.relation')
|
|
|
|
relation, = RelationType.create([{
|
|
'name': 'Relation',
|
|
}])
|
|
|
|
A, B, C = Party.create([{
|
|
'name': "A",
|
|
'contact_mechanisms': [
|
|
('create', [{'value': "A", 'type': 'other'}])],
|
|
}, {
|
|
'name': "B",
|
|
'contact_mechanisms': [
|
|
('create', [{'value': "B", 'type': 'other'}])],
|
|
}, {
|
|
'name': "C",
|
|
'contact_mechanisms': [
|
|
('create', [{'value': "C", 'type': 'other'}])],
|
|
}])
|
|
|
|
Relation.create([{
|
|
'from_': A.id,
|
|
'to': C.id,
|
|
'type': relation.id,
|
|
}])
|
|
|
|
with Transaction().set_context(related_party=A.id):
|
|
contact_mechanisms = ContactMechanism.search([])
|
|
self.assertEqual(
|
|
[c.value for c in contact_mechanisms],
|
|
['A', 'C', 'B'])
|
|
|
|
|
|
del ModuleTestCase
|