cherrypy-foundation 1.0.0__py3-none-any.whl

cherrypy_foundation/plugins/tests/test_ldap.py

@@ -0,0 +1,451 @@
+# LDAP Plugins for cherrypy
+# Copyright (C) 2026 IKUS Software
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+Created on Oct 17, 2015
+
+@author: Patrik Dufresne <patrik@ikus-soft.com>
+"""
+import os
+from unittest import TestCase, mock, skipUnless
+
+import cherrypy
+import ldap3
+from cherrypy.test import helper
+
+from ..ldap import all_attribute, first_attribute  # noqa
+
+original_connection = ldap3.Connection
+
+
+def mock_ldap_connection(*args, **kwargs):
+    kwargs.pop('client_strategy', None)
+    return original_connection(*args, client_strategy=ldap3.MOCK_ASYNC, **kwargs)
+
+
+class LdapFirstAttributeTest(TestCase):
+
+    def test_no_keys_returns_default(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertIsNone(first_attribute(attributes, None))
+        self.assertEqual(first_attribute(attributes, [], default="fallback"), "fallback")
+
+    def test_single_key_with_scalar_value(self):
+        attributes = {"uid": "jdoe"}
+        self.assertEqual(first_attribute(attributes, "uid"), "jdoe")
+
+    def test_single_key_with_list_value(self):
+        attributes = {"mail": ["john@example.com", "alt@example.com"]}
+        self.assertEqual(first_attribute(attributes, "mail"), "john@example.com")
+
+    def test_empty_list_value_is_skipped(self):
+        attributes = {
+            "mail": [],
+            "uid": ["jdoe"],
+        }
+        self.assertEqual(first_attribute(attributes, ["mail", "uid"]), "jdoe")
+
+    def test_missing_first_key_uses_next_key(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertEqual(first_attribute(attributes, ["sn", "cn"]), "John Doe")
+
+    def test_all_keys_missing_returns_default(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertEqual(first_attribute(attributes, ["sn", "uid"], default="unknown"), "unknown")
+
+    def test_key_not_found_without_default_returns_none(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertIsNone(first_attribute(attributes, "uid"))
+
+
+class LdapAllAttributeTest(TestCase):
+
+    def test_no_keys_returns_default(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertIsNone(all_attribute(attributes, None))
+        self.assertEqual(all_attribute(attributes, [], default="fallback"), "fallback")
+
+    def test_single_key_with_scalar_value(self):
+        attributes = {"uid": "jdoe"}
+        self.assertEqual(all_attribute(attributes, "uid"), ["jdoe"])
+
+    def test_single_key_with_list_value(self):
+        attributes = {"mail": ["john@example.com", "alt@example.com"]}
+        self.assertEqual(all_attribute(attributes, "mail"), ["john@example.com"])
+
+    def test_multiple_keys_collect_values(self):
+        attributes = {
+            "uid": "jdoe",
+            "cn": ["John Doe"],
+        }
+        self.assertEqual(all_attribute(attributes, ["uid", "cn"]), ["jdoe", "John Doe"])
+
+    def test_missing_keys_are_skipped(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertEqual(all_attribute(attributes, ["sn", "cn", "uid"]), ["John Doe"])
+
+    def test_all_keys_missing_returns_default(self):
+        attributes = {"cn": ["John Doe"]}
+        self.assertEqual(all_attribute(attributes, ["sn", "uid"], default=[]), [])
+
+    def test_empty_list_value_is_appended_as_empty_list(self):
+        attributes = {
+            "mail": [],
+            "uid": "jdoe",
+        }
+        self.assertEqual(all_attribute(attributes, ["mail", "uid"]), [[], "jdoe"])
+
+
+class LdapPluginTest(helper.CPWebCase):
+
+    @classmethod
+    def setup_server(cls):
+        # Configure Mock server early.
+        cls.server = ldap3.Server('my_fake_server')
+        cls.patcher = mock.patch('ldap3.Connection', side_effect=mock_ldap_connection)
+        cls.patcher.start()
+        cherrypy.config.update(
+            {
+                'ldap.uri': 'my_fake_server',
+                'ldap.base_dn': 'dc=example,dc=org',
+                'ldap.email_attribute': ['mail', 'email'],
+                'ldap.fullname_attribute': ['displayName'],
+                'ldap.firstname_attribute': ['givenName'],
+                'ldap.lastname_attribute': ['sn'],
+            }
+        )
+
+    @classmethod
+    def teardown_class(cls):
+        cherrypy.ldap.uri = None
+        # Release mock server.
+        cls.patcher.stop()
+        return super().teardown_class()
+
+    def setUp(self) -> None:
+        # Clear LDAP entries before test.
+        for entry in list(cherrypy.ldap._pool.strategy.connection.server.dit):
+            if entry == 'cn=schema':
+                continue
+            cherrypy.ldap._pool.strategy.remove_entry(entry)
+        return super().setUp()
+
+    def test_authenticate(self):
+        # Given a user in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is authenticated
+        self.assertTrue(authenticated)
+        self.assertEqual(authenticated[0], 'user01')
+        self.assertEqual(
+            {
+                'dn': 'cn=user01,dc=example,dc=org',
+                'userPassword': ['password1'],
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'cn': ['user01'],
+                'email': None,
+                'fullname': '',
+            },
+            authenticated[1],
+        )
+
+    def test_authenticate_with_wildcard(self):
+        # Given a user in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        # When authenticating with a username containing wildcard
+        authenticated = cherrypy.ldap.authenticate('user*', 'password1')
+        # Then user is NOT authenticated
+        self.assertFalse(authenticated)
+
+    def test_authenticate_with_invalid_user(self):
+        # Given a user in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        # When authenticating with an invalid user
+        authenticated = cherrypy.ldap.authenticate('invalid', 'password1')
+        # Then user is authenticated
+        self.assertEqual(False, authenticated)
+
+    def test_authenticate_with_invalid_password(self):
+        # Given a user in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        # When authenticating with an invalid user
+        authenticated = cherrypy.ldap.authenticate('user01', 'invalid')
+        # Then user is not authenticated
+        self.assertEqual(False, authenticated)
+        # When authenticating with an valid password
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is not authenticated
+        self.assertTrue(authenticated)
+
+    def test_authenticate_with_email(self):
+        # Given a user in LDAP with firstname and lastname
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'cn': ['user01'],
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'mail': ['john@test.com'],
+            },
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is authenticated and firstname is composed of firstname and lastname
+        self.assertTrue(authenticated)
+        self.assertEqual(authenticated[0], 'user01')
+        self.assertEqual(
+            {
+                'dn': 'cn=user01,dc=example,dc=org',
+                'cn': ['user01'],
+                'userPassword': ['password1'],
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'mail': ['john@test.com'],
+                'email': 'john@test.com',
+                'fullname': '',
+            },
+            authenticated[1],
+        )
+
+    def test_authenticate_with_fullname(self):
+        # Given a user in LDAP with firstname and lastname
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'cn': ['user01'],
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'displayName': ['John Kennedy'],
+            },
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is authenticated and firstname is composed of firstname and lastname
+        self.assertTrue(authenticated)
+        self.assertEqual(authenticated[0], 'user01')
+        self.assertEqual(
+            {
+                'dn': 'cn=user01,dc=example,dc=org',
+                'cn': ['user01'],
+                'userPassword': ['password1'],
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'displayName': ['John Kennedy'],
+                'email': None,
+                'fullname': 'John Kennedy',
+            },
+            authenticated[1],
+        )
+
+    def test_authenticate_with_firstname_lastname(self):
+        # Given a user in LDAP with firstname and lastname
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'cn': ['user01'],
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'givenName': ['John'],
+                'sn': ['Kennedy'],
+            },
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is authenticated and firstname is composed of firstname and lastname
+        self.assertTrue(authenticated)
+        self.assertEqual(authenticated[0], 'user01')
+        self.assertEqual(
+            {
+                'dn': 'cn=user01,dc=example,dc=org',
+                'cn': ['user01'],
+                'userPassword': ['password1'],
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'givenName': ['John'],
+                'sn': ['Kennedy'],
+                'email': None,
+                'fullname': 'John Kennedy',
+            },
+            authenticated[1],
+        )
+
+
+class LdapPluginTestWithRequiredGroup(helper.CPWebCase):
+
+    @classmethod
+    def setup_server(cls):
+        # Configure Mock server early.
+        cls.server = ldap3.Server('my_fake_server')
+        cls.conn = ldap3.Connection(cls.server, client_strategy=ldap3.MOCK_ASYNC, raise_exceptions=True)
+        cls.patcher = mock.patch('ldap3.Connection', return_value=cls.conn)
+        cls.patcher.start()
+        cherrypy.config.update(
+            {
+                'ldap.uri': 'my_fake_server',
+                'ldap.base_dn': 'dc=example,dc=org',
+                'ldap.required_group': ['appgroup', 'secondgroup'],
+                'ldap.group_attribute': 'memberUid',
+                'ldap.group_attribute_is_dn': False,
+            }
+        )
+
+    @classmethod
+    def teardown_class(cls):
+        cherrypy.ldap.uri = None
+        # Release mock server.
+        cls.patcher.stop()
+        return super().teardown_class()
+
+    def setUp(self) -> None:
+        # Clear LDAP entries before test.
+        for entry in list(cherrypy.ldap._pool.strategy.connection.server.dit):
+            if entry == 'cn=schema':
+                continue
+            cherrypy.ldap._pool.strategy.remove_entry(entry)
+        return super().setUp()
+
+    def test_authenticate_with_valid_group(self):
+        # Given a user and a group in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=appgroup,ou=Groups,dc=example,dc=org',
+            {
+                'cn': ['appgroup'],
+                'memberUid': ['user01', 'user02'],
+                'objectClass': ['posixGroup'],
+            },
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is authenticated
+        self.assertTrue(authenticated)
+        self.assertEqual(authenticated[0], 'user01')
+        self.assertEqual(
+            {
+                'dn': 'cn=user01,dc=example,dc=org',
+                'userPassword': ['password1'],
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+                'cn': ['user01'],
+                'email': None,
+                'fullname': '',
+            },
+            authenticated[1],
+        )
+
+    def test_authenticate_with_not_member(self):
+        # Given a user and a group in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=appgroup,ou=Groups,dc=nodomain', {'memberUid': ['invalid', 'user02'], 'objectClass': ['posixGroup']}
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is not authenticated
+        self.assertEqual(False, authenticated)
+
+    def test_authenticate_with_invalid_group(self):
+        # Given a user and a group in LDAP
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=user01,dc=example,dc=org',
+            {
+                'userPassword': 'password1',
+                'uid': ['user01'],
+                'objectClass': ['person', 'organizationalPerson', 'inetOrgPerson', 'posixAccount'],
+            },
+        )
+        cherrypy.ldap._pool.strategy.add_entry(
+            'cn=invalid,ou=Groups,dc=nodomain', {'memberUid': ['user01', 'user02'], 'objectClass': ['posixGroup']}
+        )
+        # When authenticating with that user
+        authenticated = cherrypy.ldap.authenticate('user01', 'password1')
+        # Then user is not authenticated
+        self.assertEqual(False, authenticated)
+
+
+@skipUnless(os.environ.get('TEST_LDAP_URI', None), "required TEST_LDAP_URI pointing to openldap server")
+class LdapPluginTestWithOpenldap(helper.CPWebCase):
+    """
+    This test required a real openldap serer running with 'user01' and 'password1'.
+    """
+
+    @classmethod
+    def setup_server(cls):
+        cherrypy.config.update(
+            {
+                'ldap.uri': os.environ.get('TEST_LDAP_URI'),
+                'ldap.base_dn': os.environ.get('TEST_LDAP_BASE_DN', 'dc=example,dc=org'),
+            }
+        )
+
+    @classmethod
+    def teardown_class(cls):
+        cherrypy.ldap.uri = None
+        return super().teardown_class()
+
+    def test_authenticate(self):
+        user = cherrypy.ldap.authenticate('user01', 'password1')
+        self.assertTrue(user)
+        self.assertEqual(user[0], 'user01')
+
+    def test_authenticate_with_invalid_user(self):
+        self.assertEqual(False, cherrypy.ldap.authenticate('josh', 'password'))

cherrypy_foundation/plugins/tests/test_scheduler.py

@@ -0,0 +1,100 @@
+# Scheduler plugins for Cherrypy
+# Copyright (C) 2026 IKUS Software
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from datetime import datetime, timezone
+from threading import Event
+
+import cherrypy
+from cherrypy.test import helper
+
+from .. import scheduler  # noqa
+
+done = Event()
+
+
+def a_task(*args, **kwargs):
+    done.set()
+
+
+class SchedulerPluginTest(helper.CPWebCase):
+    def setUp(self) -> None:
+        done.clear()
+        cherrypy.scheduler.remove_all_jobs()
+        return super().setUp()
+
+    def tearDown(self):
+        return super().tearDown()
+
+    @classmethod
+    def setup_server(cls):
+        pass
+
+    def test_add_job(self):
+        # Given a scheduled job
+        scheduled = cherrypy.engine.publish(
+            'scheduler:add_job',
+            a_task,
+            name='custom_name',
+            args=(1, 2, 3),
+            kwargs={'foo': 'bar'},
+            next_run_time=datetime.now(timezone.utc),
+            misfire_grace_time=None,
+        )
+        self.assertTrue(scheduled)
+        self.assertEqual('custom_name', scheduled[0].name)
+        # When waiting for all jobs
+        cherrypy.scheduler.wait_for_jobs()
+        # Then the job is done
+        self.assertTrue(done.is_set())
+
+    def test_add_job_daily(self):
+        # Given a scheduler with a specific number of jobs
+        count = len(cherrypy.scheduler.get_jobs())
+        # When scheduling a daily job.
+        scheduled = cherrypy.engine.publish('scheduler:add_job_daily', '23:00', a_task, 1, 2, 3, foo=1, bar=2)
+        # Then the job is scheduled
+        self.assertTrue(scheduled)
+        self.assertEqual('a_task', scheduled[0].name)
+        # Then the number of jobs increase.
+        self.assertEqual(count + 1, len(cherrypy.scheduler.get_jobs()))
+
+    def test_add_job_now(self):
+        # Given a task
+        # When scheduling that task
+        scheduled = cherrypy.engine.publish('scheduler:add_job_now', a_task, 1, 2, 3, foo=1, bar=2)
+        self.assertTrue(scheduled)
+        # When waiting for all tasks
+        cherrypy.scheduler.wait_for_jobs()
+        # Then the task get called
+        self.assertTrue(done.is_set())
+
+    def test_remove_job(self):
+        # Given a scheduler with a specific number of jobs
+        count = len(cherrypy.scheduler.get_jobs())
+        # Given a job schedule every seconds
+        cherrypy.engine.publish('scheduler:add_job_daily', '23:00', a_task, 1, 2, 3, foo=1, bar=2)
+        # Then number of job increase
+        self.assertEqual(count + 1, len(cherrypy.scheduler.get_jobs()))
+        # When the job is unscheduled.
+        cherrypy.engine.publish('scheduler:remove_job', a_task)
+        # Then the number of job decrease.
+        self.assertEqual(count, len(cherrypy.scheduler.get_jobs()))
+
+    def test_remove_job_with_invalid_job(self):
+        # Given an unschedule job
+        # When unscheduling an invalid job
+        cherrypy.engine.publish('scheduler:remove_job', a_task)
+        # Then an error is not raised.

cherrypy_foundation/plugins/tests/test_scheduler_db.py

@@ -0,0 +1,107 @@
+# Scheduler plugins for Cherrypy
+# Copyright (C) 2026 IKUS Software
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+import importlib
+import tempfile
+from threading import Event
+
+import cherrypy
+from cherrypy.test import helper
+
+from .. import scheduler  # noqa
+
+done = Event()
+
+HAS_SQLALCHEMY = importlib.util.find_spec("sqlalchemy") is not None
+if not HAS_SQLALCHEMY:
+    pass
+else:
+    from sqlalchemy import Column, Integer, String
+    from sqlalchemy.exc import IntegrityError
+
+    from .. import db  # noqa
+
+    Base = cherrypy.db.get_base()
+
+    class User2(Base):
+        __tablename__ = 'users2'
+        id = Column(Integer, primary_key=True)
+        username = Column(String)
+
+        def __repr__(self):
+            return f"User2(id={self.id}, username='{self.username}')"
+
+    class Root:
+
+        @cherrypy.expose
+        def index(self):
+            return str(User2.query.all())
+
+        @cherrypy.expose
+        def add(self, username):
+            try:
+                User2(username=username).add().commit()
+                return "OK"
+            except IntegrityError as e:
+                return str(e)
+
+    def create_user(*args, **kwargs):
+        user = User2(*args, **kwargs).add()
+        user.commit()
+        done.set()
+
+
+class DbSchedulerPluginTest(helper.CPWebCase):
+    interactive = False
+
+    @classmethod
+    def setup_class(cls):
+        cls.tempdir = tempfile.TemporaryDirectory(prefix='cherrypy-foundation-', suffix='-db-test')
+        super().setup_class()
+
+    @classmethod
+    def teardown_class(cls):
+        cls.tempdir.cleanup()
+        super().teardown_class()
+
+    @classmethod
+    def setup_server(cls):
+        cherrypy.config.update(
+            {
+                'db.uri': f"sqlite:///{cls.tempdir.name}/data.db",
+            }
+        )
+        cherrypy.tree.mount(Root(), '/')
+
+    def setUp(self) -> None:
+        done.clear()
+        cherrypy.db.create_all()
+        return super().setUp()
+
+    def tearDown(self):
+        cherrypy.db.drop_all()
+        return super().tearDown()
+
+    def test_add_job_now(self):
+        # Given a task
+        # When scheduling that task
+        scheduled = cherrypy.engine.publish('scheduler:add_job_now', create_user, username='myuser')
+        self.assertTrue(scheduled)
+        # When waiting for all tasks
+        cherrypy.scheduler.wait_for_jobs()
+        # Then the task get called
+        self.assertTrue(done.is_set())
+        # Then database was updated
+        User2.query.filter(User2.username == 'myuser').one()