From ea30313c4375591c9c982c38d88f3fb17e4481ef Mon Sep 17 00:00:00 2001 From: Guewen Baconnier Date: Mon, 23 Jul 2018 17:34:00 +0200 Subject: [PATCH] Add tests for the server env mixin --- server_environment/models/server_env_mixin.py | 3 +- test_server_environment/README.rst | 46 ++++++ test_server_environment/__init__.py | 1 + test_server_environment/__manifest__.py | 19 +++ test_server_environment/models/__init__.py | 1 + .../models/server_env_test.py | 45 ++++++ .../security/ir.model.access.csv | 2 + test_server_environment/tests/__init__.py | 1 + .../tests/test_server_env_mixin.py | 133 ++++++++++++++++++ 9 files changed, 250 insertions(+), 1 deletion(-) create mode 100644 test_server_environment/README.rst create mode 100644 test_server_environment/__init__.py create mode 100644 test_server_environment/__manifest__.py create mode 100644 test_server_environment/models/__init__.py create mode 100644 test_server_environment/models/server_env_test.py create mode 100644 test_server_environment/security/ir.model.access.csv create mode 100644 test_server_environment/tests/__init__.py create mode 100644 test_server_environment/tests/test_server_env_mixin.py diff --git a/server_environment/models/server_env_mixin.py b/server_environment/models/server_env_mixin.py index 09c5264..2f56e1a 100644 --- a/server_environment/models/server_env_mixin.py +++ b/server_environment/models/server_env_mixin.py @@ -136,7 +136,7 @@ class ServerEnvMixin(models.AbstractModel): }, "sftp_port": { "getter": "getint", - },, + }, "sftp_login": {}, "sftp_password": {}, } @@ -319,6 +319,7 @@ class ServerEnvMixin(models.AbstractModel): def _server_env_transform_field_to_read_from_env(self, field): """Transform the original field in a computed field""" field.compute = '_compute_server_env' + inverse_method_name = '_inverse_server_env_%s' % field.name inverse_method = partialmethod( ServerEnvMixin._inverse_server_env, field.name diff --git a/test_server_environment/README.rst b/test_server_environment/README.rst new file mode 100644 index 0000000..107a17a --- /dev/null +++ b/test_server_environment/README.rst @@ -0,0 +1,46 @@ +.. image:: https://img.shields.io/badge/licence-AGPL--3-blue.svg + :target: http://www.gnu.org/licenses/agpl-3.0-standalone.html + :alt: License: AGPL-3 + +======================= +Test Server Environment +======================= + +This addon is not meant to be used. It extends the Odoo Models +in order to run automated tests on the Server Environment module. + +Same basic tests are integrated within the ``server_environment`` addon. + +Usage +===== + +This module only contains Python tests. + +Credits +======= + +Images +------ + +* Odoo Community Association: `Icon `_. + +Contributors +------------ + +* Guewen Baconnier + +Maintainer +---------- + +.. image:: https://odoo-community.org/logo.png + :alt: Odoo Community Association + :target: https://odoo-community.org + +This module is maintained by the OCA. + +OCA, or the Odoo Community Association, is a nonprofit organization whose +mission is to support the collaborative development of Odoo features and +promote its widespread use. + +To contribute to this module, please visit https://odoo-community.org. + diff --git a/test_server_environment/__init__.py b/test_server_environment/__init__.py new file mode 100644 index 0000000..0650744 --- /dev/null +++ b/test_server_environment/__init__.py @@ -0,0 +1 @@ +from . import models diff --git a/test_server_environment/__manifest__.py b/test_server_environment/__manifest__.py new file mode 100644 index 0000000..345336a --- /dev/null +++ b/test_server_environment/__manifest__.py @@ -0,0 +1,19 @@ +# Copyright 2018 Camptocamp (https://www.camptocamp.com). +# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). + +{ + "name": "Automated tests for server environment - technical", + "summary": "Used to run automated tests, do not install", + "version": "11.0.1.0.0", + "depends": [ + "server_environment", + ], + "author": "Camptocamp,Odoo Community Association (OCA)", + "website": "http://odoo-community.org/", + "license": "GPL-3 or any later version", + "category": "Tools", + "data": [ + 'security/ir.model.access.csv', + ], + 'installable': True, +} diff --git a/test_server_environment/models/__init__.py b/test_server_environment/models/__init__.py new file mode 100644 index 0000000..9caabd0 --- /dev/null +++ b/test_server_environment/models/__init__.py @@ -0,0 +1 @@ +from . import server_env_test diff --git a/test_server_environment/models/server_env_test.py b/test_server_environment/models/server_env_test.py new file mode 100644 index 0000000..2251839 --- /dev/null +++ b/test_server_environment/models/server_env_test.py @@ -0,0 +1,45 @@ +# Copyright 2018 Camptocamp (https://www.camptocamp.com). +# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). + +""" Models used for testing server_environment + +Create models that will be used in tests. + +""" + +from odoo import fields, models + + +class ServerEnvTest(models.Model): + _name = 'server.env.test' + _description = 'Server Environment Test Model' + + name = fields.Char(required=True) + # if the original field is required, it must not + # be required anymore as we set it with config + host = fields.Char(required=True) + port = fields.Integer() + user = fields.Char() + password = fields.Char() + ssl = fields.Boolean() + + +# Intentionally re-declares a class to stress the inclusion of the mixin +class ServerEnvTestWithMixin(models.Model): + _name = 'server.env.test' + _inherit = ['server.env.test', 'server.env.mixin'] + + @property + def _server_env_fields(self): + base_fields = super()._server_env_fields + sftp_fields = { + "host": {}, + "port": { + "getter": "getint", + }, + "user": {}, + "password": {}, + "ssl": {}, + } + sftp_fields.update(base_fields) + return sftp_fields diff --git a/test_server_environment/security/ir.model.access.csv b/test_server_environment/security/ir.model.access.csv new file mode 100644 index 0000000..2d95da4 --- /dev/null +++ b/test_server_environment/security/ir.model.access.csv @@ -0,0 +1,2 @@ +id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink +access_server_env_test,access_server_env_test,model_server_env_test,,1,0,0,0 diff --git a/test_server_environment/tests/__init__.py b/test_server_environment/tests/__init__.py new file mode 100644 index 0000000..4952af4 --- /dev/null +++ b/test_server_environment/tests/__init__.py @@ -0,0 +1 @@ +from . import test_server_env_mixin diff --git a/test_server_environment/tests/test_server_env_mixin.py b/test_server_environment/tests/test_server_env_mixin.py new file mode 100644 index 0000000..4af655d --- /dev/null +++ b/test_server_environment/tests/test_server_env_mixin.py @@ -0,0 +1,133 @@ +# Copyright 2018 Camptocamp (https://www.camptocamp.com). +# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). + +from contextlib import contextmanager + +from odoo.addons.server_environment import server_env +from odoo.addons.server_environment.tests.common import ServerEnvironmentCase + +import odoo.addons.server_environment.models.server_env_mixin as \ + server_env_mixin + + +class TestServerEnvMixin(ServerEnvironmentCase): + + @contextmanager + def load_config(self, public=None, secret=None): + original_serv_config = server_env_mixin.serv_config + try: + with self.set_config_dir(None), \ + self.set_env_variables(public, secret): + parser = server_env._load_config() + server_env_mixin.serv_config = parser + yield + + finally: + server_env_mixin.serv_config = original_serv_config + + def test_env_computed_fields_read(self): + """Read values from the config in env-computed fields""" + public = ( + # global for all server.env.test records + "[server_env_test]\n" + "ssl=1\n" + # for our server.env.test test record now + "[server_env_test.foo]\n" + "host=test.example.com\n" + "port=21\n" + "user=foo\n" + ) + secret = ( + "[server_env_test.foo]\n" + "password=bar\n" + ) + # we can create the record even if we didn't provide + # the field host which was required + foo = self.env['server.env.test'].create({ + 'name': 'foo', + }) + with self.load_config(public, secret): + self.assertEqual(foo.name, 'foo') + self.assertEqual(foo.host, 'test.example.com') + self.assertEqual(foo.port, 21) + self.assertEqual(foo.user, 'foo') + self.assertEqual(foo.password, 'bar') + self.assertTrue(foo.ssl) + + def test_env_computed_fields_write(self): + """Env-computed fields without key in config can be written""" + public = ( + # for our server.env.test test record now + "[server_env_test.foo]\n" + "host=test.example.com\n" + "port=21\n" + ) + secret = ( + "[server_env_test.foo]\n" + "password=bar\n" + ) + # we can create the record even if we didn't provide + # the field host which was required + foo = self.env['server.env.test'].create({ + 'name': 'foo', + }) + with self.load_config(public, secret): + self.assertEqual(foo.host, 'test.example.com') + self.assertFalse(foo.host_env_is_editable) + self.assertEqual(foo.port, 21) + self.assertFalse(foo.port_env_is_editable) + self.assertEqual(foo.password, 'bar') + self.assertFalse(foo.password_env_is_editable) + + self.assertFalse(foo.user) + self.assertTrue(foo.user_env_is_editable) + self.assertFalse(foo.ssl) + self.assertTrue(foo.ssl_env_is_editable) + + # field set in config, no effect + foo.host = 'new.example.com' + self.assertFalse(foo.host_env_default) + + # fields not set in config, written + foo.user = 'dummy' + self.assertEqual(foo.user_env_default, 'dummy') + foo.ssl = True + self.assertTrue(foo.ssl_env_default) + + def test_env_computed_default(self): + """Env-computed fields read from default fields""" + # we can create the record even if we didn't provide + # the field host which was required + foo = self.env['server.env.test'].create({ + 'name': 'foo', + }) + # empty files + with self.load_config(): + self.assertFalse(foo.host) + self.assertFalse(foo.port) + self.assertFalse(foo.password) + self.assertFalse(foo.user) + self.assertFalse(foo.ssl) + + self.assertTrue(foo.host_env_is_editable) + self.assertTrue(foo.port_env_is_editable) + self.assertTrue(foo.password_env_is_editable) + self.assertTrue(foo.user_env_is_editable) + self.assertTrue(foo.ssl_env_is_editable) + + foo.write({ + 'host_env_default': 'test.example.com', + 'port_env_default': 21, + 'password_env_default': 'bar', + 'user_env_default': 'foo', + 'ssl_env_default': True, + }) + + # refresh env-computed fields, it should read from + # the default fields + foo.invalidate_cache() + self.assertEqual(foo.host, 'test.example.com') + self.assertEqual(foo.port, 21) + self.assertEqual(foo.user, 'foo') + self.assertEqual(foo.password, 'bar') + self.assertTrue(foo.ssl)