proteus 7.8.0__py3-none-any.whl

proteus/tests/__init__.py

@@ -0,0 +1,9 @@
+# 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 os
+
+os.environ.setdefault('TRYTOND_DATABASE_URI', 'sqlite:///')
+os.environ.setdefault('DB_NAME', ':memory:')
+
+here = os.path.dirname(__file__)
+readme = os.path.normpath(os.path.join(here, '..', '..', 'README.rst'))

proteus/tests/common.py

@@ -0,0 +1,17 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+from unittest import TestCase
+
+from proteus import config
+from trytond.tests.test_tryton import create_db, db_exist
+
+
+class ProteusTestCase(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        if not db_exist():
+            create_db()
+
+    def setUp(self):
+        self.config = config.set_trytond()

proteus/tests/test_action.py

@@ -0,0 +1,49 @@
+# 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 unittest
+
+try:
+    import pydot
+except ImportError:
+    pydot = None
+
+from proteus import Model, Wizard, launch_action
+
+from .common import ProteusTestCase
+
+
+class TestAction(ProteusTestCase):
+
+    def test_act_window(self):
+        IrModel = Model.get('ir.model')
+        actions = IrModel.find([
+                ('name', '=', 'ir.action'),
+                ])
+        model_access = launch_action(
+            'ir.act_model_access_form_relate_model', actions)
+        self.assertEqual(
+            {m.__class__.__name__ for m in model_access},
+            {'ir.model.access'})
+
+    def test_wizard(self):
+        IrModel = Model.get('ir.model')
+        actions = IrModel.find([
+                ('name', '=', 'ir.action'),
+                ])
+        wizard = launch_action('ir.print_model_graph', actions)
+        self.assertIsInstance(wizard, Wizard)
+        self.assertEqual(wizard.name, 'ir.model.print_model_graph')
+
+    @unittest.skipIf(not pydot, 'requires pydot')
+    def test_report(self):
+        IrModel = Model.get('ir.model')
+        actions = IrModel.find([
+                ('name', '=', 'ir.action'),
+                ])
+        ftype, data, direct_print, report_name = launch_action(
+            'ir.report_model_workflow_graph', actions)
+        self.assertIsInstance(ftype, str)
+        self.assertIsInstance(data, bytes)
+        self.assertIsInstance(direct_print, bool)
+        self.assertIsInstance(report_name, str)

proteus/tests/test_config.py

@@ -0,0 +1,40 @@
+# 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 proteus.config
+
+from .common import ProteusTestCase
+
+
+class TestConfig(ProteusTestCase):
+
+    def test_proxy(self):
+        config = proteus.config.get_config()
+        user_proxy = config.get_proxy('res.user')
+        user_id = user_proxy.search([('login', '=', 'admin')], 0, 1, None,
+                config.context)[0]
+        self.assertTrue(user_id == config.user)
+
+    def test_proxy_keyword(self):
+        config = proteus.config.get_config()
+        user_proxy = config.get_proxy('res.user')
+        user_id, = user_proxy.search(
+            [('login', '=', 'admin')], limit=1, context=config.context)
+        self.assertTrue(user_id == config.user)
+
+    def test_proxy_methods(self):
+        config = proteus.config.get_config()
+        self.assertTrue('search' in config.get_proxy_methods('res.user'))
+
+    def test_trytond_config_eq(self):
+        config1 = proteus.config.get_config()
+        proteus.config.set_trytond()
+        config2 = proteus.config.get_config()
+        self.assertEqual(config1, config2)
+
+        self.assertRaises(NotImplementedError, config1.__eq__, None)
+
+    def test_repr(self):
+        config = proteus.config.TrytondConfig('sqlite:///:memory:')
+        self.assertEqual(repr(config),
+            "proteus.config.TrytondConfig("
+            "'sqlite:///:memory:', 'admin', config_file=None)")

proteus/tests/test_context.py

@@ -0,0 +1,16 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of this
+# repository contains the full copyright notices and license terms.
+from .common import ProteusTestCase
+
+
+class TestContext(ProteusTestCase):
+
+    def test_config(self):
+        prev_ctx = self.config._context
+
+        with self.config.set_context({'a': 1}):
+            self.assertEqual(self.config.context['a'], 1)
+            for key, value in prev_ctx.items():
+                self.assertEqual(self.config.context[key], value)
+
+        self.assertEqual(self.config.context, prev_ctx)

proteus/tests/test_model.py

@@ -0,0 +1,406 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+from proteus import Model
+
+from .common import ProteusTestCase
+
+
+class TestModel(ProteusTestCase):
+
+    def test_class_cache(self):
+        User1 = Model.get('res.user')
+        User2 = Model.get('res.user')
+        self.assertEqual(id(User1), id(User2))
+
+        Model.reset()
+        User3 = Model.get('res.user')
+        self.assertNotEqual(id(User1), id(User3))
+
+    def test_class_method(self):
+        User = Model.get('res.user')
+        self.assertTrue(len(User.search([('login', '=', 'admin')], {})))
+
+    def test_int(self):
+        User = Model.get('res.user')
+        admin = User.find([('login', '=', 'admin')])[0]
+        self.assertEqual(int(admin), admin.id)
+
+    def test_id_zero(self):
+        User = Model.get('res.user')
+        root = User(0)
+        self.assertEqual(root.login, 'root')
+
+    def test_find(self):
+        User = Model.get('res.user')
+        admin = User.find([('login', '=', 'admin')])[0]
+        self.assertEqual(admin.login, 'admin')
+
+    def test_many2one(self):
+        User = Model.get('res.user')
+        admin = User.find([('login', '=', 'admin')])[0]
+        self.assertTrue(isinstance(admin.create_uid, User))
+        try:
+            admin.create_uid = 'test'
+            self.fail()
+        except AssertionError:
+            pass
+        admin.create_uid = admin
+        admin.create_uid = None
+
+        User(write_uid=None)
+
+    def test_one2many(self):
+        Group = Model.get('res.group')
+        administration = Group.find([('name', '=', 'Administration')])[0]
+        self.assertTrue(isinstance(administration.model_access, list))
+        self.assertTrue(isinstance(administration.model_access[0],
+            Model.get('ir.model.access')))
+        try:
+            administration.model_access = []
+            self.fail()
+        except AttributeError:
+            pass
+
+    def test_many2many(self):
+        User = Model.get('res.user')
+        admin = User.find([('login', '=', 'admin')])[0]
+        self.assertTrue(isinstance(admin.groups, list))
+        self.assertTrue(isinstance(admin.groups[0],
+            Model.get('res.group')))
+        try:
+            admin.groups = []
+            self.fail()
+        except AttributeError:
+            pass
+
+    def test_many2many_append_unique(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+        admin, = User.find([('login', '=', 'admin')])
+        group = Group(admin.groups[0].id)
+        admin.groups.append(group)
+
+        self.assertEqual(admin.groups.count(group), 1)
+
+    def test_many2many_extend_unique(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+        admin, = User.find([('login', '=', 'admin')])
+        group = Group(admin.groups[0].id)
+        admin.groups.extend([group])
+
+        self.assertEqual(admin.groups.count(group), 1)
+
+    # TODO test date
+
+    def test_reference(self):
+        Attachment = Model.get('ir.attachment')
+        User = Model.get('res.user')
+        admin = User.find([('login', '=', 'admin')])[0]
+        attachment = Attachment()
+        attachment.name = 'Test'
+        attachment.resource = admin
+        attachment.save()
+        self.assertEqual(attachment.resource, admin)
+
+    def test_id_counter(self):
+        User = Model.get('res.user')
+        test1 = User()
+        self.assertTrue(test1.id < 0)
+        test2 = User()
+        self.assertTrue(test2.id < 0)
+        self.assertNotEqual(test1.id, test2.id)
+
+    def test_init(self):
+        User = Model.get('res.user')
+        self.assertEqual(User(1).id, 1)
+        self.assertEqual(User(name='Foo').name, 'Foo')
+
+        Lang = Model.get('ir.lang')
+        en, = Lang.find([('code', '=', 'en')])
+        self.assertEqual(User(language=en).language, en)
+        self.assertEqual(User(language=en.id).language, en)
+
+        Group = Model.get('res.group')
+        groups = Group.find()
+        self.assertEqual(len(User(groups=groups).groups), len(groups))
+        self.assertEqual(len(User(groups=[x.id for x in groups]).groups),
+                len(groups))
+
+    def test_assign_unknown_field(self):
+        "Test it is not allowed to assign unknown field"
+        User = Model.get('res.user')
+        user = User()
+
+        with self.assertRaises(AttributeError):
+            user.unknown_field = 'foo'
+
+    def test_save(self):
+        User = Model.get('res.user')
+        test = User()
+        test.name = 'Test'
+        test.login = 'test'
+        test.save()
+        self.assertTrue(test.id > 0)
+
+        test = User(test.id)
+        self.assertEqual(test.name, 'Test')
+        self.assertEqual(test.login, 'test')
+        self.assertTrue(test.active)
+
+        test.signature = 'Test signature'
+        self.assertEqual(test.signature, 'Test signature')
+        test.save()
+        self.assertEqual(test.signature, 'Test signature')
+        test = User(test.id)
+        self.assertEqual(test.signature, 'Test signature')
+
+        Group = Model.get('res.group')
+        test2 = User(name='Test 2', login='test2',
+                groups=[Group(name='Test 2')])
+        test2.save()
+        self.assertTrue(test2.id > 0)
+        self.assertEqual(test2.name, 'Test 2')
+        self.assertEqual(test2.login, 'test2')
+
+        test.signature = 'classmethod save'
+        test2.name = 'Test 2 classmethod'
+        test3 = User(name='Test 3', login='test3')
+        User.save([test, test2, test3])
+        self.assertEqual(test.signature, 'classmethod save')
+        self.assertEqual(test2.name, 'Test 2 classmethod')
+        self.assertTrue(test3.id > 0)
+        self.assertEqual(test3.name, 'Test 3')
+
+    def test_save_many2one(self):
+        User = Model.get('res.user')
+        test = User()
+        test.name = 'Test save many2one'
+        test.login = 'test_save_many2one'
+        test.save()
+
+        Lang = Model.get('ir.lang')
+        en, = Lang.find([('code', '=', 'en')])
+        test.language = en
+        test.save()
+        self.assertEqual(test.language, en)
+
+        test.language = None
+        test.save()
+        self.assertFalse(test.language)
+
+    def test_save_one2many(self):
+        Group = Model.get('res.group')
+        group = Group()
+        group.name = 'Test save one2many'
+        group.save()
+
+        ModelAccess = Model.get('ir.model.access')
+        model_access = ModelAccess()
+        model_access.model = 'res.group'
+        model_access.perm_read = True
+        model_access.perm_write = True
+        model_access.perm_create = True
+        model_access.perm_delete = True
+
+        group.model_access.append(model_access)
+        group.save()
+        self.assertEqual(len(group.model_access), 1)
+
+        model_access_id = group.model_access[0].id
+
+        group.name = 'Test save one2many bis'
+        group.model_access[0].description = 'Test save one2many'
+        group.save()
+        self.assertEqual(group.model_access[0].description,
+                'Test save one2many')
+
+        group.model_access.pop()
+        group.save()
+        self.assertEqual(group.model_access, [])
+        self.assertEqual(len(ModelAccess.find([('id', '=', model_access_id)])),
+                1)
+
+        group.model_access.append(ModelAccess(model_access_id))
+        group.save()
+        self.assertEqual(len(group.model_access), 1)
+
+        group.model_access.remove(group.model_access[0])
+        group.save()
+        self.assertEqual(group.model_access, [])
+        self.assertEqual(len(ModelAccess.find([('id', '=', model_access_id)])),
+                0)
+
+    def test_save_many2many(self):
+        User = Model.get('res.user')
+        test = User()
+        test.name = 'Test save many2many'
+        test.login = 'test_save_many2many'
+        test.save()
+
+        Group = Model.get('res.group')
+        group = Group()
+        group.name = 'Test save many2many'
+        group.save()
+
+        test.groups.append(group)
+        test.save()
+        self.assertEqual(len(test.groups), 1)
+
+        group_id = test.groups[0].id
+
+        test.name = 'Test save many2many bis'
+        test.groups[0].name = 'Test save many2many bis'
+        test.save()
+        self.assertEqual(test.groups[0].name,
+                'Test save many2many bis')
+
+        test.groups.pop()
+        test.save()
+        self.assertEqual(test.groups, [])
+        self.assertEqual(len(Group.find([('id', '=', group_id)])), 1)
+
+        test.groups.append(Group(group_id))
+        test.save()
+        self.assertEqual(len(test.groups), 1)
+
+        test.groups.remove(test.groups[0])
+        test.save()
+        self.assertEqual(test.groups, [])
+        self.assertEqual(len(Group.find([('id', '=', group_id)])), 0)
+
+    def test_eq(self):
+        User = Model.get('res.user')
+        test = User()
+        test.name = 'Test eq'
+        test.login = 'test_eq'
+        test.save()
+        admin1 = User.find([('login', '=', 'admin')])[0]
+        admin2 = User.find([('login', '=', 'admin')])[0]
+
+        self.assertEqual(admin1, admin2)
+        self.assertFalse(admin1 != admin2)
+        self.assertNotEqual(admin1, test)
+        self.assertFalse(admin1 == test)
+        self.assertNotEqual(admin1, None)
+        self.assertNotEqual(admin1, False)
+        self.assertNotEqual(admin1, 1)
+
+    def test_lt(self):
+        User = Model.get('res.user')
+
+        user1 = User(1)
+        user2 = User(2)
+
+        self.assertLess(user1, user2)
+
+    def test_lt_other_model(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+
+        user1 = User(1)
+        group2 = Group(2)
+
+        with self.assertRaises(TypeError):
+            user1 < group2
+
+    def test_default_set(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+        group_ids = [x.id for x in Group.find()]
+        test = User()
+        test._default_set({
+            'name': 'Test',
+            'groups': group_ids,
+            })
+        self.assertEqual(test.name, 'Test')
+        self.assertEqual([x.id for x in test.groups], group_ids)
+
+        test = User()
+        test._default_set({
+            'name': 'Test',
+            'groups': [
+                {
+                    'name': 'Group 1',
+                },
+                {
+                    'name': 'Group 2',
+                },
+                ],
+            })
+        self.assertEqual(test.name, 'Test')
+        self.assertEqual([x.name for x in test.groups], ['Group 1', 'Group 2'])
+
+    def test_delete(self):
+        Group = Model.get('res.group')
+        test = Group()
+        test.name = 'Test delete'
+        test.save()
+        test.delete()
+
+    def test_duplicate(self):
+        User = Model.get('res.user')
+        test = User()
+        test.name = 'Test duplicate'
+        test.login = 'test duplicate'
+        test.save()
+        copy, = User.duplicate([test], {'name': 'Test copy'})
+        self.assertEqual(copy.name, 'Test copy')
+        self.assertEqual(copy.login, 'test duplicate (copy)')
+        self.assertNotEqual(copy.id, test.id)
+
+    def test_on_change(self):
+        Trigger = Model.get('ir.trigger')
+
+        trigger = Trigger()
+
+        trigger.on_time_ = True
+        self.assertEqual(trigger.on_create_, False)
+
+        trigger.on_create_ = True
+        self.assertEqual(trigger.on_time_, False)
+
+    def test_on_change_with(self):
+        Attachment = Model.get('ir.attachment')
+
+        attachment = Attachment()
+
+        attachment.description = 'Test'
+        self.assertEqual(attachment.summary, 'Test')
+
+    def test_on_change_set(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+
+        test = User()
+        test._on_change_set('name', 'Test')
+        self.assertEqual(test.name, 'Test')
+        group_ids = [x.id for x in Group.find()]
+        test._on_change_set('groups', group_ids)
+        self.assertEqual([x.id for x in test.groups], group_ids)
+
+        test._on_change_set('groups', {'remove': [group_ids[0]]})
+        self.assertEqual([x.id for x in test.groups], group_ids[1:])
+
+        test._on_change_set('groups', {'add': [(-1, {
+                            'name': 'Bar',
+                            })]})
+        self.assertTrue([x for x in test.groups if x.name == 'Bar'])
+
+        test.groups.extend(Group.find())
+        group = test.groups[0]
+        test._on_change_set('groups', {'update': [{
+            'id': group.id,
+            'name': 'Foo',
+            }]})
+        self.assertTrue([x for x in test.groups if x.name == 'Foo'])
+
+    def test_model_list_find(self):
+        User = Model.get('res.user')
+        Group = Model.get('res.group')
+
+        test = User()
+        groups = test.groups.find(order=[('id', 'ASC')])
+        all_groups = Group.find([], order=[('id', 'ASC')])
+
+        self.assertListEqual(groups, all_groups)

proteus/tests/test_readme.py

@@ -0,0 +1,23 @@
+# 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 doctest
+import os
+
+import proteus
+import proteus.config
+from trytond.tests.test_tryton import doctest_setup, doctest_teardown
+
+here = os.path.dirname(__file__)
+readme = os.path.normpath(os.path.join(here, '..', '..', 'README.rst'))
+
+
+def load_tests(loader, tests, pattern):
+    for mod in (proteus, proteus.config):
+        tests.addTest(doctest.DocTestSuite(mod))
+    if os.path.isfile(readme):
+        tests.addTest(doctest.DocFileSuite(
+                readme, module_relative=False,
+                setUp=doctest_setup, tearDown=doctest_teardown,
+                encoding='utf-8',
+                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE))
+    return tests

proteus/tests/test_report.py

@@ -0,0 +1,29 @@
+# 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 unittest
+
+try:
+    import pydot
+except ImportError:
+    pydot = None
+
+from proteus import Model, Report
+
+from .common import ProteusTestCase
+
+
+class TestReport(ProteusTestCase):
+
+    @unittest.skipIf(not pydot, 'requires pydot')
+    def test_model_graph(self):
+        IrModel = Model.get('ir.model')
+        models = IrModel.find([])
+        data = {
+            'level': 1,
+            'filter': '',
+            }
+        report = Report('ir.model.graph')
+        type_, data, print_, name = report.execute(models, data)
+        self.assertEqual(type_, 'png')
+        self.assertEqual(print_, False)
+        self.assertEqual(name, 'Graph')

proteus/tests/test_wizard.py

@@ -0,0 +1,54 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+from proteus import Model, Wizard
+
+from .common import ProteusTestCase
+
+
+class TestWizard(ProteusTestCase):
+
+    def test_translation_clean(self):
+        translation_clean = Wizard('ir.translation.clean')
+        self.assertEqual(translation_clean.form.__class__.__name__,
+                'ir.translation.clean.start')
+        translation_clean.execute('clean')
+        self.assertEqual(translation_clean.form.__class__.__name__,
+            'ir.translation.clean.succeed')
+
+    def test_translation_export(self):
+        Lang = Model.get('ir.lang')
+        Module = Model.get('ir.module')
+        translation_export = Wizard('ir.translation.export')
+        translation_export.form.language, = Lang.find([('code', '=', 'en')])
+        translation_export.form.module, = Module.find([('name', '=', 'ir')])
+        translation_export.execute('export')
+        self.assertTrue(translation_export.form.file)
+        translation_export.execute('end')
+
+    def test_user_config(self):
+        User = Model.get('res.user')
+
+        user_config = Wizard('res.user.config')
+        user_config.execute('user')
+        user_config.form.name = 'Foo'
+        user_config.form.login = 'foo'
+        user_config.execute('add')
+        self.assertEqual(user_config.form.name, None)
+        self.assertEqual(user_config.form.login, None)
+        user_config.form.name = 'Bar'
+        user_config.form.login = 'bar'
+        user_config.execute('end')
+
+        self.assertTrue(User.find([('name', '=', 'Foo')]))
+        self.assertFalse(User.find([('name', '=', 'Bar')]))
+
+    def test_translation_update(self):
+        print_model_graph = Wizard('ir.translation.update')
+        self.assertEqual(len(print_model_graph.actions), 0)
+        print_model_graph.execute('update')
+        self.assertEqual(len(print_model_graph.actions), 1)
+
+    def test_configuration_wizard(self):
+        config_wizard = Wizard('ir.module.config_wizard')
+        config_wizard.execute('action')
+        self.assertTrue(config_wizard.actions)