first commit

modules/party_relationship/tests/__init__.py

@@ -0,0 +1,2 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.

modules/party_relationship/tests/test_module.py

@@ -0,0 +1,295 @@
+# 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