Merge branch 'fix/better_runner' of github.com:tracim/tracim_backend into fix/few_more_tests

development.ini.sample

 # app configuration
 # https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/environment.html
 ###
-[app:main]
+[pipeline:main]
+pipeline = tracim_web
+[app:tracim_web]
 use = egg:tracim_backend
 
 pyramid.reload_templates = true
 pyramid.includes =
     pyramid_debugtoolbar
 
+[pipeline:webdav]
+pipeline = tracim_webdav
+[app:tracim_webdav]
+use = egg:tracim_backend#webdav
+
+[DEFAULT]
 sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
 
 retry.attempts = 3

setup.py

     install_requires=requires,
     entry_points={
         'paste.app_factory': [
-            'main = tracim:main',
+            'main = tracim:web',
+            'webdav = tracim:webdav'
         ],
         'console_scripts': [
             'tracimcli = tracim.command:main',

tracim/__init__.py

 from tracim.lib.utils.authentification import BASIC_AUTH_WEBUI_REALM
 from tracim.lib.utils.authorization import AcceptAllAuthorizationPolicy
 from tracim.lib.utils.authorization import TRACIM_DEFAULT_PERM
+from tracim.lib.webdav import WebdavAppFactory
 from tracim.views import BASE_API_V2
 from tracim.views.core_api.session_controller import SessionController
 from tracim.views.errors import ErrorSchema
 from tracim.lib.utils.cors import add_cors_support
 
 
-def main(global_config, **settings):
+def web(global_config, **local_settings):
     """ This function returns a Pyramid WSGI application.
     """
+    settings = global_config
+    settings.update(local_settings)
     # set CFG object
     app_config = CFG(settings)
     app_config.configure_filedepot()
         'API of Tracim v2',
     )
     return configurator.make_wsgi_app()
+
+
+def webdav(global_config, **local_settings):
+    settings = global_config
+    settings.update(local_settings)
+    app_factory = WebdavAppFactory(
+        tracim_config_file_path=settings['__file__'],
+    )
+    return app_factory.get_wsgi_app()

tracim/command/webdav.py

 
 from tracim.command import AppContextCommand
 from tracim.lib.webdav import WebdavAppFactory
+from wsgi import webdav_app
 
 
 class WebdavRunnerCommand(AppContextCommand):
         super(WebdavRunnerCommand, self).take_action(parsed_args)
         tracim_config = parsed_args.config_file
         # TODO - G.M - 16-04-2018 - Allow specific webdav config file
-        app_factory = WebdavAppFactory(
-            tracim_config_file_path=tracim_config,
-        )
-        app = app_factory.get_wsgi_app()
+        app = webdav_app(tracim_config)
         serve(app, port=app.config['port'], host=app.config['host'])

tracim/lib/webdav/__init__.py

 class WebdavAppFactory(object):
 
     def __init__(self,
-                 webdav_config_file_path: str = None,
                  tracim_config_file_path: str = None,
                  ):
         self.config = self._initConfig(
-            webdav_config_file_path,
             tracim_config_file_path
         )
 
     def _initConfig(self,
-                    webdav_config_file_path: str = None,
                     tracim_config_file_path: str = None
                     ):
         """Setup configuration dictionary from default,
          command line and configuration file."""
-        if not webdav_config_file_path:
-            webdav_config_file_path = DEFAULT_WEBDAV_CONFIG_FILE
         if not tracim_config_file_path:
             tracim_config_file_path = DEFAULT_TRACIM_CONFIG_FILE
 
         # Set config defaults
         config = DEFAULT_CONFIG.copy()
         temp_verbose = config["verbose"]
+        # Get pyramid Env
+        tracim_config_file_path = os.path.abspath(tracim_config_file_path)
+        config['tracim_config'] = tracim_config_file_path
+        settings = self._get_tracim_settings(config)
+        app_config = CFG(settings)
 
-        default_config_file = os.path.abspath(webdav_config_file_path)
+        default_config_file = os.path.abspath(settings['wsgidav.config_path'])
         webdav_config_file = self._readConfigFile(
-            webdav_config_file_path,
+            default_config_file,
             temp_verbose
             )
         # Configuration file overrides defaults
         config.update(webdav_config_file)
 
-        # Get pyramid Env
-        tracim_config_file_path = os.path.abspath(tracim_config_file_path)
-        config['tracim_config'] = tracim_config_file_path
-        settings = get_appsettings(config['tracim_config'])
-        app_config = CFG(settings)
-
         if not useLxml and config["verbose"] >= 1:
             print(
                 "WARNING: Could not import lxml: using xml instead (slower). "
         config['domaincontroller'] = TracimDomainController(
             presetdomain=None,
             presetserver=None,
-            app_config = app_config,
+            app_config=app_config,
         )
         return config
 
+    def _get_tracim_settings(
+            self,
+            default_config,
+    ):
+        """
+        Get tracim settings
+        """
+        global_conf = get_appsettings(default_config['tracim_config']).global_conf
+        local_conf = get_appsettings(default_config['tracim_config'], 'tracim_web')  # nopep8
+        settings = global_conf
+        settings.update(local_conf)
+        return settings
+
     # INFO - G.M - 13-04-2018 - Copy from
     # wsgidav.server.run_server._readConfigFile
     def _readConfigFile(self, config_file, verbose):

tracim/lib/webdav/middlewares.py

         super().__init__(application, config)
         self._application = application
         self._config = config
-        self.settings = get_appsettings(config['tracim_config'])
+        global_conf = get_appsettings(config['tracim_config']).global_conf
+        local_conf = get_appsettings(config['tracim_config'], 'tracim_web')
+        self.settings = global_conf
+        self.settings.update(local_conf)
         self.engine = get_engine(self.settings)
         self.session_factory = get_session_factory(self.engine)
         self.app_config = CFG(self.settings)

tracim/tests/__init__.py

 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from tracim.config import CFG
 from tracim.extensions import hapic
-from tracim import main
+from tracim import web
 from webtest import TestApp
 
 
         self.run_app()
 
     def run_app(self):
-        app = main({}, **self.settings)
+        app = web({}, **self.settings)
+        self.init_database(self.settings)
         self.testapp = TestApp(app)
 
     def init_database(self, settings):

tracim/tests/library/test_webdav.py

 
 import pytest
 from sqlalchemy.exc import InvalidRequestError
-
+from wsgidav.wsgidav_app import DEFAULT_CONFIG
+from tracim import WebdavAppFactory
 from tracim.lib.core.user import UserApi
+from tracim.lib.webdav import TracimDomainController
 from tracim.tests import eq_
 from tracim.lib.core.notifications import DummyNotifier
 from tracim.lib.webdav.dav_provider import Provider
 from tracim.fixtures.content import Content as ContentFixtures
 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from wsgidav import util
+from unittest.mock import MagicMock
+
+
+class TestWebdavFactory(StandardTest):
+
+    def test_unit__initConfig__ok__nominal_case(self):
+        """
+        Check if config is correctly modify for wsgidav using mocked
+        wsgidav and tracim conf (as dict)
+        :return:
+        """
+        tracim_settings = {
+            'sqlalchemy.url': 'sqlite:///:memory:',
+            'user.auth_token.validity': '604800',
+            'depot_storage_dir': '/tmp/test/depot',
+            'depot_storage_name': 'test',
+            'preview_cache_dir': '/tmp/test/preview_cache',
+            'wsgidav.config_path': 'development.ini'
+
+        }
+        wsgidav_setting = DEFAULT_CONFIG.copy()
+        wsgidav_setting.update(
+            {
+               'root_path':  '',
+               'acceptbasic': True,
+               'acceptdigest': False,
+               'defaultdigest': False,
+            }
+        )
+        mock = MagicMock()
+        mock._initConfig = WebdavAppFactory._initConfig
+        mock._readConfigFile.return_value = wsgidav_setting
+        mock._get_tracim_settings.return_value = tracim_settings
+        config = mock._initConfig(mock)
+        assert config
+        assert config['acceptbasic'] is True
+        assert config['acceptdigest'] is False
+        assert config['defaultdigest'] is False
+        # TODO - G.M - 25-05-2018 - Better check for middleware stack config
+        assert 'middleware_stack' in config
+        assert len(config['middleware_stack']) == 7
+        assert 'root_path' in config
+        assert 'provider_mapping' in config
+        assert config['root_path'] in config['provider_mapping']
+        assert isinstance(config['provider_mapping'][config['root_path']], Provider)  # nopep8
+        assert 'domaincontroller' in config
+        assert isinstance(config['domaincontroller'], TracimDomainController)
 
 
 class TestWebDav(StandardTest):

wsgi/__init__.py

+# coding=utf-8
+import plaster
+import pyramid.paster
+
+from tracim.lib.webdav import WebdavAppFactory
+
+
+def web_app(config_uri):
+    pyramid.paster.setup_logging(config_uri)
+    return pyramid.paster.get_app(config_uri)
+
+
+def webdav_app(config_uri):
+    config_uri = '{}#webdav'.format(config_uri)
+    plaster.setup_logging(config_uri)
+    loader = plaster.get_loader(config_uri, protocols=['wsgi'])
+    return loader.get_wsgi_app()

wsgi/web.py

 # coding=utf-8
 # Runner for uwsgi
 import os
-import pyramid.paster
+from wsgi import web_app
 
 config_uri = os.environ['TRACIM_CONF_PATH']
-
-pyramid.paster.setup_logging(config_uri)
-application = pyramid.paster.get_app(config_uri)
+application = web_app(config_uri)

wsgi/webdav.py

 # coding=utf-8
 # Runner for uwsgi
-from tracim.lib.webdav import WebdavAppFactory
 import os
+from wsgi import webdav_app
 
 config_uri = os.environ['TRACIM_CONF_PATH']
-webdav_config_uri = os.environ['TRACIM_WEBDAV_CONF_PATH']
-app_factory = WebdavAppFactory(
-    tracim_config_file_path=config_uri,
-    webdav_config_file_path=webdav_config_uri,
-)
-application = app_factory.get_wsgi_app()
+application = webdav_app(config_uri)