changeset d837ddb269b5 in modules/party_relationship:default
details:
https://hg.tryton.org/modules/party_relationship?cmd=changeset&node=d837ddb269b5
description:
Replace test setuptools command by unittest discover
issue9215
review389851002
diffstat:
setup.py | 6 +-
tests/__init__.py | 8 -
tests/test_module.py | 295 ++++++++++++++++++++++++++++++++++++++
tests/test_party_relationship.py | 300 ---------------------------------------
tox.ini | 3 +-
5 files changed, 300 insertions(+), 312 deletions(-)
diffs (651 lines):
diff -r 3b2ce0d0cf6e -r d837ddb269b5 setup.py
--- a/setup.py Sun Apr 10 19:11:38 2022 +0200
+++ b/setup.py Sat Apr 16 18:30:17 2022 +0200
@@ -137,13 +137,13 @@
license='GPL-3',
python_requires='>=3.7',
install_requires=requires,
+ extras_require={
+ 'test': tests_require,
+ },
dependency_links=dependency_links,
zip_safe=False,
entry_points="""
[trytond.modules]
party_relationship = trytond.modules.party_relationship
""",
- test_suite='tests',
- test_loader='trytond.test_loader:Loader',
- tests_require=tests_require,
)
diff -r 3b2ce0d0cf6e -r d837ddb269b5 tests/__init__.py
--- a/tests/__init__.py Sun Apr 10 19:11:38 2022 +0200
+++ b/tests/__init__.py Sat Apr 16 18:30:17 2022 +0200
@@ -1,10 +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.
-
-try:
- from trytond.modules.party_relationship.tests.test_party_relationship
import \
- suite # noqa: E501
-except ImportError:
- from .test_party_relationship import suite
-
-__all__ = ['suite']
diff -r 3b2ce0d0cf6e -r d837ddb269b5 tests/test_module.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test_module.py Sat Apr 16 18:30:17 2022 +0200
@@ -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
diff -r 3b2ce0d0cf6e -r d837ddb269b5 tests/test_party_relationship.py
--- a/tests/test_party_relationship.py Sun Apr 10 19:11:38 2022 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,300 +0,0 @@
-# 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
-from trytond.tests.test_tryton import suite as tryton_suite
-from trytond.tests.test_tryton import 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'])
-
-
-def suite():
- suite = tryton_suite()
- suite.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCase))
- return suite
diff -r 3b2ce0d0cf6e -r d837ddb269b5 tox.ini
--- a/tox.ini Sun Apr 10 19:11:38 2022 +0200
+++ b/tox.ini Sat Apr 16 18:30:17 2022 +0200
@@ -2,8 +2,9 @@
envlist = {py37,py38,py39,py310}-{sqlite,postgresql}
[testenv]
+extras = test
commands =
- coverage run --include=.*/party_relationship/* setup.py test
+ coverage run --include=.*/party_relationship/* -m unittest discover -s
tests
coverage report --include=.*/party_relationship/* --omit=*/tests/*
deps =
coverage
