Add tests for the server env mixin

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

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 <https://github.com/OCA/maintainer-tools/blob/master/template/module/static/description/icon.svg>`_.
+
+Contributors
+------------
+
+* Guewen Baconnier <guewen.baconnier@camptocamp.com>
+
+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.
+

test_server_environment/__init__.py

@@ -0,0 +1 @@
+from . import models

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,
+}

test_server_environment/models/__init__.py

@@ -0,0 +1 @@
+from . import server_env_test

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

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

test_server_environment/tests/__init__.py

@@ -0,0 +1 @@
+from . import test_server_env_mixin

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)