Radicale: tests: fix for multiples tests + test auth

install/requirements.txt

 unicode-slugify==0.1.3
 Radicale==1.1.1
 icalendar==3.10
+caldav==0.4.0

tracim/tracim/lib/daemons.py

 import threading
 from wsgiref.simple_server import make_server
 import signal
+
+import collections
 import transaction
 
 from radicale import Application as RadicaleApplication
 
     def stop_all(self, *args, **kwargs) -> None:
         """
-        Stop all started daemons and w<ait for them.
+        Stop all started daemons and wait for them.
         """
         logger.info(self, 'Stopping all daemons')
         for name, daemon in self._running_daemons.items():
 
         self._running_daemons = {}
 
+    def execute_in_thread(self, thread_name, callback):
+        self._running_daemons[thread_name].append_thread_callback(callback)
+
 
 class TracimSocketServerMixin(object):
     """
     Mixin to use with socketserver.BaseServer who add _after_serve_actions
     method executed after end of server execution.
     """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._daemon_execute_callbacks = []
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        """
+        Add callback to self._daemon_execute_callbacks. See service_actions
+        function to their usages.
+        :param callback: callback to execute in daemon
+        """
+        self._daemon_execute_callbacks.append(callback)
+
     def serve_forever(self, *args, **kwargs):
         super().serve_forever(*args, **kwargs)
         # After serving (in case of stop) do following:
         Override (and call super if needed) to execute actions when server
         finish it's job.
         """
-        transaction.commit()
+        pass
+
+    def service_actions(self):
+        if len(self._daemon_execute_callbacks):
+            try:
+                while True:
+                    self._daemon_execute_callbacks.pop()()
+            except IndexError:
+                pass  # Finished to iter
 
 
 class Daemon(threading.Thread):
     Thread who contains daemon. You must implement start and stop methods to
     manage daemon life correctly.
     """
-    def run(self):
+    def run(self) -> None:
+        """
+        Place here code who have to be executed in Daemon.
+        """
         raise NotImplementedError()
 
-    def stop(self):
+    def stop(self) -> None:
+        """
+        Place here code who stop your daemon
+        """
+        raise NotImplementedError()
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        """
+        Place here the logic who permit to execute a callback in your daemon.
+        To get an exemple of that, take a look at
+        socketserver.BaseServer#service_actions  and how we use it in
+        tracim.lib.daemons.TracimSocketServerMixin#service_actions .
+        :param callback: callback to execute in your thread.
+        """
         raise NotImplementedError()
 
 
             RadicaleHTTPSServer if cfg.RADICALE_SERVER_SSL else RadicaleHTTPServer,
             RadicaleRequestHandler
         )
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        """
+        Give the callback to running server through
+        tracim.lib.daemons.TracimSocketServerMixin#append_thread_callback
+        :param callback: callback to execute in daemon
+        """
+        self._server.append_thread_callback(callback)

tracim/tracim/tests/__init__.py

 
 from tracim.fixtures import FixturesLoader
 from tracim.fixtures.users_and_groups import Base as BaseFixture
-from tracim.config.app_cfg import daemons
+from tracim.fixtures.users_and_groups import Test as TestFixture
+from tracim.config.app_cfg import daemons, start_daemons
 from tracim.lib.base import logger
 from tracim.lib.content import ContentApi
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model import DBSession, Content
 from tracim.model.data import Workspace, ContentType, ContentRevisionRO
+from tracim.lib.calendar import CALENDAR_BASE_URL
 
 __all__ = ['setup_app', 'setup_db', 'teardown_db', 'TestController']
 
     def tearDown(self):
         """Tear down test fixture for each functional test method."""
         DBSession.close()
-        daemons.stop_all()
+        daemons.execute_in_thread('radicale', lambda: transaction.commit())
         teardown_db()
 
 
 
 
 class TestCalendar(TestController):
+    fixtures = [BaseFixture, TestFixture]
     application_under_test = 'radicale'
 
     def setUp(self):
                 os.remove('{0}/{1}'.format(radicale_fs_path, file))
         except FileNotFoundError:
             pass  # Dir not exists yet, no need to clear it
+
+    def _get_base_url(self):
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+
+        return CALENDAR_BASE_URL.format(
+            proto='https' if cfg.RADICALE_CLIENT_SSL else 'http',
+            domain=cfg.RADICALE_CLIENT_HOST or '127.0.0.1',
+            port=str(cfg.RADICALE_CLIENT_PORT)
+        )

tracim/tracim/tests/functional/test_calendar.py

 import time
 
+import caldav
+from caldav.lib.error import AuthorizationError
 from nose.tools import eq_, ok_
 import requests
 from requests.exceptions import ConnectionError
 
-from tracim.lib.calendar import CALENDAR_BASE_URL
 from tracim.tests import TestCalendar as BaseTestCalendar
 
 
 class TestCalendar(BaseTestCalendar):
-    def test_unit__radicale_connectivity__ok__nominal_case(self):
-        from tracim.config.app_cfg import CFG
-        cfg = CFG.get_instance()
+    def test_func__radicale_connectivity__ok__nominal_case(self):
+        radicale_base_url = self._get_base_url()
 
-        radicale_base_url = CALENDAR_BASE_URL.format(
-            proto='https' if cfg.RADICALE_CLIENT_SSL else 'http',
-            domain=cfg.RADICALE_CLIENT_HOST or '127.0.0.1',
-            port=str(cfg.RADICALE_CLIENT_PORT)
-        )
         try:
             time.sleep(2)  # TODO - 20160606 - Bastien: sleep to wait ...
             # ... radicale daemon started. We should lock something somewhere !
             eq_(response.status_code, 401, 'Radicale http response is 401')
         except ConnectionError:
             ok_(False, 'Unable to contact radicale on HTTP')
+
+    def test_func__radicale_auth__ok__as_lawrence(self):
+        client = caldav.DAVClient('http://127.0.0.1:15232',
+                                  username='lawrence-not-real-email@fsf.local',
+                                  password='foobarbaz')
+        try:
+            client.propfind()
+            ok_(True, 'No auth error when communicate with radicale server')
+        except AuthorizationError:
+            ok_(False, 'AuthorizationError when communicate with radicale')