Fix post-merge failing tests

.travis.yml

   - "3.5"
   - "3.6"
 
+services:
+  - docker
+  - redis-server
+
+before_install:
+  - docker pull mailhog/mailhog
+  - docker run -d -p 1025:1025 -p 8025:8025 mailhog/mailhog
 install:
   - pip install --upgrade pip setuptools
   - pip install -e ".[testing]"

README.md

     sudo apt update
     sudo apt install git
     sudo apt install python3 python3-venv python3-dev python3-pip
+    sudo apt install redis-server
 
 ### Get the source ###
 
 
     tracimcli webdav start
 
+
 ## Run Tests and others checks ##
 
+### Run Tests ###
+
+Before running some functional test related to email, you need a local working *MailHog*
+see here : https://github.com/mailhog/MailHog
+
+You can run it this way with docker :
+
+    docker pull mailhog/mailhog
+    docker run -d -p 1025:1025 -p 8025:8025 mailhog/mailhog
+
 Run your project's tests:
 
     pytest
 
+### Lints and others checks ###
+
 Run mypy checks:
 
     mypy --ignore-missing-imports --disallow-untyped-defs tracim

development.ini.old

+###
+# app configuration
+# https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/environment.html
+###
+[app:main]
+use = egg:tracim_backend
+
+pyramid.reload_templates = true
+pyramid.debug_authorization = false
+pyramid.debug_notfound = false
+pyramid.debug_routematch = false
+pyramid.default_locale_name = en
+pyramid.includes =
+    pyramid_debugtoolbar
+
+sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
+
+retry.attempts = 3
+
+# By default, the toolbar only appears for clients from IP addresses
+# '127.0.0.1' and '::1'.
+# debugtoolbar.hosts = 127.0.0.1 ::1
+
+###
+# TRACIM SPECIFIC CONF
+###
+
+### Global
+debug = false
+cache_dir = %(here)s/data
+# preview generator cache directory
+preview_cache_dir = /tmp/tracim/preview/
+# file depot storage
+depot_storage_name = tracim
+depot_storage_dir = %(here)s/depot/
+
+# The following parameters allow to personalize the home page
+# They are html ready (you can put html tags they will be interpreted)
+website.title = TRACIM
+website.title.color = #555
+website.home.subtitle = Default login: email: admin@admin.admin (password: admin@admin.admin)
+website.home.tag_line = <div class="text-center" style="font-weight: bold;">Collaboration, versionning and traceability</div>
+website.home.below_login_form = in case of problem, please contact the administrator.
+# Values may be 'all' or 'folders'
+website.treeview.content = all
+# The following base_url is used for links and icons
+# integrated in the email notifcations
+website.base_url = http://127.0.0.1:8080
+# If config not provided, it will be extracted from website.base_url
+website.server_name = 127.0.0.1
+
+# Specifies if the update of comments and attached files is allowed (by the owner only).
+# Examples:
+#    600 means 10 minutes (ie 600 seconds)
+#   3600 means 1 hour (60x60 seconds)
+#
+# Allowed values:
+#  -1 means that content update is allowed for ever
+#   0 means that content update is not allowed
+#   x means that content update is allowed for x seconds (with x>0)
+content.update.allowed.duration = 3600
+
+# Auth type (internal or ldap)
+auth_type = internal
+# If auth_type is ldap, uncomment following ldap_* parameters
+# LDAP server address
+# ldap_url = ldap://localhost:389
+# Base dn to make queries
+# ldap_base_dn = dc=directory,dc=fsf,dc=org
+# Bind dn to identify the search
+# ldap_bind_dn = cn=admin,dc=directory,dc=fsf,dc=org
+# The bind password
+# ldap_bind_pass = toor
+# Attribute name of user record who contain user login (email)
+# ldap_ldap_naming_attribute = uid
+# Matching between ldap attribute and ldap user field (ldap_attr1=user_field1,ldap_attr2=user_field2,...)
+# ldap_user_attributes = mail=email
+# TLS usage to communicate with your LDAP server
+# ldap_tls = False
+# If True, LDAP own tracim group managment (not available for now!)
+# ldap_group_enabled = False
+# User auth token validity in seconds (used to interfaces like web calendars)
+user.auth_token.validity = 604800
+
+### Mail
+
+# Reset password through email related configuration.
+# These emails will be sent through SMTP
+#
+resetpassword.email_sender = email@sender.com
+resetpassword.smtp_host = smtp.sender
+resetpassword.smtp_port = 25
+resetpassword.smtp_login = smtp.login
+resetpassword.smtp_passwd = smtp.password
+
+email.notification.activated = False
+# email.notification.log_file_path = /tmp/mail-notifications.log
+# email notifications can be sent with the user_id added as an identifier
+# this way email clients like Thunderbird will be able to distinguish
+# notifications generated by a user or another one
+email.notification.from.email = noreply+{user_id}@trac.im
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = reply+{content_id}@trac.im
+email.notification.references.email = thread+{content_id}@trac.im
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = sync
+email.notification.smtp.server = your_smtp_server
+email.notification.smtp.port = 25
+email.notification.smtp.user = your_smtp_user
+email.notification.smtp.password = your_smtp_password
+
+## Email sending configuration
+# processing_mode may be sync or async,
+# with async, please configure redis below
+email.processing_mode = sync
+# email.async.redis.host = localhost
+# email.async.redis.port = 6379
+# email.async.redis.db = 0
+
+# Email reply configuration
+email.reply.activated = False
+email.reply.imap.server = your_imap_server
+email.reply.imap.port = 993
+email.reply.imap.user = your_imap_user
+email.reply.imap.password = your_imap_password
+email.reply.imap.folder = INBOX
+email.reply.imap.use_ssl = true
+email.reply.imap.use_idle = true
+# Re-new connection each 10 minutes
+email.reply.connection.max_lifetime = 600
+# Token for communication between mail fetcher and tracim controller
+email.reply.token = mysecuretoken
+# Delay in seconds between each check
+email.reply.check.heartbeat = 60
+email.reply.use_html_parsing = true
+email.reply.use_txt_parsing = true
+# Lockfile path is required for email_reply feature,
+# it's just an empty file use to prevent concurrent access to imap unseen mail
+email.reply.lockfile_path = %(here)s/email_fetcher.lock
+
+### Radical (CalDav server) configuration
+
+# radicale.server.host = 0.0.0.0
+# radicale.server.port = 5232
+# radicale.server.ssl = false
+radicale.server.filesystem.folder = %(here)s/radicale/collections/
+# radicale.server.allow_origin = *
+# radicale.server.realm_message = Tracim Calendar - Password Required
+## url can be extended like http://127.0.0.1:5232/calendar
+## in this case, you have to create your own proxy behind this url.
+## and update following parameters
+# radicale.client.base_url.host = http://127.0.0.1:5232
+# radicale.client.base_url.prefix = /
+
+### WSGIDAV
+
+wsgidav.config_path = %(here)s/wsgidav.conf
+## url can be extended like 127.0.0.1/webdav
+## in this case, you have to create your own proxy behind this url.
+## Do not set http:// prefix.
+# wsgidav.client.base_url = 127.0.0.1:<WSGIDAV_PORT>
+
+###
+# wsgi server configuration
+###
+
+[server:main]
+use = egg:waitress#main
+listen = localhost:6543
+
+[alembic]
+# path to migration scripts
+script_location = tracim/migration
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# timezone to use when rendering the date
+# within the migration file as well as the filename.
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; this defaults
+# to migrate/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path
+# version_locations = %(here)s/bar %(here)s/bat migrate/versions
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
+
+###
+# logging configuration
+# https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/logging.html
+###
+
+[loggers]
+keys = root, tracim, sqlalchemy, alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = INFO
+handlers = console
+
+[logger_tracim]
+level = DEBUG
+handlers =
+qualname = tracim
+
+[logger_sqlalchemy]
+level = INFO
+handlers =
+qualname = sqlalchemy.engine
+# "level = INFO" logs SQL queries.
+# "level = DEBUG" logs SQL queries and results.
+# "level = WARN" logs neither.  (Recommended for production systems.)
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(asctime)s %(levelname)-5.5s [%(name)s:%(lineno)s][%(threadName)s] %(message)s
+datefmt = %H:%M:%S

development.ini.oloool

+###
+# app configuration
+# https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/environment.html
+###
+;[pipeline:main]
+;pipeline = tracim_web
+
+[app:main]
+use = egg:tracim_backend
+
+pyramid.reload_templates = true
+pyramid.debug_authorization = false
+pyramid.debug_notfound = false
+pyramid.debug_routematch = false
+pyramid.default_locale_name = en
+;pyramid.includes =
+;    pyramid_debugtoolbar
+
+retry.attempts = 3
+
+sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
+
+# By default, the toolbar only appears for clients from IP addresses
+# '127.0.0.1' and '::1'.
+# debugtoolbar.hosts = 127.0.0.1 ::1
+
+###
+# TRACIM SPECIFIC CONF
+###
+
+### Global
+
+cache_dir = %(here)s/data
+# preview generator cache directory
+preview_cache_dir = /tmp/tracim/preview/
+# file depot storage
+depot_storage_name = tracim
+depot_storage_dir = %(here)s/depot/
+
+# The following parameters allow to personalize the home page
+# They are html ready (you can put html tags they will be interpreted)
+website.title = TRACIM
+website.title.color = #555
+website.home.subtitle = Default login: email: admin@admin.admin (password: admin@admin.admin)
+website.home.tag_line = <div class="text-center" style="font-weight: bold;">Collaboration, versionning and traceability</div>
+website.home.below_login_form = in case of problem, please contact the administrator.
+# Values may be 'all' or 'folders'
+website.treeview.content = all
+# The following base_url is used for links and icons
+# integrated in the email notifcations
+website.base_url = http://127.0.0.1:8080
+# If config not provided, it will be extracted from website.base_url
+website.server_name = 127.0.0.1
+
+# Specifies if the update of comments and attached files is allowed (by the owner only).
+# Examples:
+#    600 means 10 minutes (ie 600 seconds)
+#   3600 means 1 hour (60x60 seconds)
+#
+# Allowed values:
+#  -1 means that content update is allowed for ever
+#   0 means that content update is not allowed
+#   x means that content update is allowed for x seconds (with x>0)
+content.update.allowed.duration = 3600
+
+# Auth type (internal or ldap)
+auth_type = internal
+# If auth_type is ldap, uncomment following ldap_* parameters
+# LDAP server address
+# ldap_url = ldap://localhost:389
+# Base dn to make queries
+# ldap_base_dn = dc=directory,dc=fsf,dc=org
+# Bind dn to identify the search
+# ldap_bind_dn = cn=admin,dc=directory,dc=fsf,dc=org
+# The bind password
+# ldap_bind_pass = toor
+# Attribute name of user record who contain user login (email)
+# ldap_ldap_naming_attribute = uid
+# Matching between ldap attribute and ldap user field (ldap_attr1=user_field1,ldap_attr2=user_field2,...)
+# ldap_user_attributes = mail=email
+# TLS usage to communicate with your LDAP server
+# ldap_tls = False
+# If True, LDAP own tracim group managment (not available for now!)
+# ldap_group_enabled = False
+# User auth token validity in seconds (used to interfaces like web calendars)
+user.auth_token.validity = 604800
+
+### Mail
+
+# Reset password through email related configuration.
+# These emails will be sent through SMTP
+#
+resetpassword.email_sender = email@sender.com
+resetpassword.smtp_host = smtp.sender
+resetpassword.smtp_port = 25
+resetpassword.smtp_login = smtp.login
+resetpassword.smtp_passwd = smtp.password
+
+email.notification.activated = false
+# email.notification.log_file_path = /tmp/mail-notifications.log
+# email notifications can be sent with the user_id added as an identifier
+# this way email clients like Thunderbird will be able to distinguish
+# notifications generated by a user or another one
+email.notification.from.email = dev.tracim.maildaemon+{user_id}@algoo.fr
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = dev.tracim.maildaemon+{content_id}@algoo.fr
+email.notification.references.email = dev.tracim.maildaemon+{content_id}@algoo.fr
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = async
+email.notification.smtp.server = mail.gandi.net
+email.notification.smtp.port = 25
+email.notification.smtp.user = dev.tracim.maildaemon@algoo.fr
+email.notification.smtp.password = dev.tracim.maildaemon
+
+## Email sending configuration
+# processing_mode may be sync or async,
+# with async, please configure redis below
+email.processing_mode = sync
+# email.async.redis.host = localhost
+# email.async.redis.port = 6379
+# email.async.redis.db = 0
+
+# Email reply configuration
+email.reply.activated = false
+email.reply.imap.server = your_imap_server
+email.reply.imap.port = 993
+email.reply.imap.user = your_imap_user
+email.reply.imap.password = your_imap_password
+email.reply.imap.folder = INBOX
+email.reply.imap.use_ssl = true
+email.reply.imap.use_idle = true
+# Re-new connection each 10 minutes
+email.reply.connection.max_lifetime = 600
+# Token for communication between mail fetcher and tracim controller
+email.reply.token = mysecuretoken
+# Delay in seconds between each check
+email.reply.check.heartbeat = 60
+email.reply.use_html_parsing = true
+email.reply.use_txt_parsing = true
+# Lockfile path is required for email_reply feature,
+# it's just an empty file use to prevent concurrent access to imap unseen mail
+email.reply.lockfile_path = %(here)s/email_fetcher.lock
+
+### Radical (CalDav server) configuration
+
+# radicale.server.host = 0.0.0.0
+# radicale.server.port = 5232
+# radicale.server.ssl = false
+radicale.server.filesystem.folder = %(here)s/radicale/collections/
+# radicale.server.allow_origin = *
+# radicale.server.realm_message = Tracim Calendar - Password Required
+## url can be extended like http://127.0.0.1:5232/calendar
+## in this case, you have to create your own proxy behind this url.
+## and update following parameters
+# radicale.client.base_url.host = http://127.0.0.1:5232
+# radicale.client.base_url.prefix = /
+
+### WSGIDAV
+
+wsgidav.config_path = %(here)s/wsgidav.conf
+## url can be extended like 127.0.0.1/webdav
+## in this case, you have to create your own proxy behind this url.
+## Do not set http:// prefix.
+# wsgidav.client.base_url = 127.0.0.1:<WSGIDAV_PORT>
+
+###
+# wsgi server configuration
+###
+[uwsgi]
+# Legacy server config (waitress)
+[server:main]
+use = egg:waitress#main
+listen = localhost:6543
+
+[alembic]
+# path to migration scripts
+script_location = tracim/migration
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# timezone to use when rendering the date
+# within the migration file as well as the filename.
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; this defaults
+# to migrate/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path
+# version_locations = %(here)s/bar %(here)s/bat migrate/versions
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
+
+###
+# logging configuration
+# https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/logging.html
+###
+
+[loggers]
+keys = root, tracim, sqlalchemy, alembic, sentry
+
+[handlers]
+keys = console, sentry
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = INFO
+handlers = console, sentry
+
+[logger_sentry]
+level = WARN
+handlers = console
+qualname = sentry.errors
+propagate = 0
+
+[logger_tracim]
+level = DEBUG
+handlers =
+qualname = tracim
+
+[logger_sqlalchemy]
+level = INFO
+handlers =
+qualname = sqlalchemy.engine
+# "level = INFO" logs SQL queries.
+# "level = DEBUG" logs SQL queries and results.
+# "level = WARN" logs neither.  (Recommended for production systems.)
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[handler_sentry]
+class = raven.handlers.logging.SentryHandler
+args = ('http://1dbab0942cca4fbb97f3dae62cbc965d:4d1deecd8abc41e38c02b37ed4954f58@127.0.0.1:9000/4',)
+level = WARNING
+formatter = generic
+
+[formatter_generic]
+format = %(asctime)s %(levelname)-5.5s [%(name)s:%(lineno)s][%(threadName)s] %(message)s
+datefmt = %H:%M:%S

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

     'zope.sqlalchemy',
     'alembic',
     # API
-    'hapic',
+    'hapic>=0.41',
     'marshmallow <3.0.0a1,>2.0.0',
     # CLI
     'cliff',
     'filedepot',
     'babel',
     'python-slugify',
+    # mail-notifier
+    'mako',
+    'lxml',
+    'redis',
+    'rq',
 ]
 
 tests_require = [
     'pytest-cov',
     'pep8',
     'mypy',
+    'requests'
 ]
 
 mysql_require = [
     install_requires=requires,
     entry_points={
         'paste.app_factory': [
-            'main = tracim:main',
+            'main = tracim:web',
+            'webdav = tracim:webdav'
         ],
         'console_scripts': [
             'tracimcli = tracim.command:main',

tests_configs.ini

+[base_test]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+
+[app:command_test]
+use = egg:tracim_backend
+sqlalchemy.url = sqlite:///tracim_test.sqlite
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+
+[mail_test]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+email.notification.activated = true
+email.notification.from.email = test_user_from+{user_id}@localhost
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = test_user_reply+{content_id}@localhost
+email.notification.references.email = test_user_refs+{content_id}@localhost
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = sync
+email.notification.smtp.server = 127.0.0.1
+email.notification.smtp.port = 1025
+email.notification.smtp.user = test_user
+email.notification.smtp.password = just_a_password
+
+[mail_test_async]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+email.notification.activated = true
+email.notification.from.email = test_user_from+{user_id}@localhost
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = test_user_reply+{content_id}@localhost
+email.notification.references.email = test_user_refs+{content_id}@localhost
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = sync
+email.processing_mode = async
+email.notification.smtp.server = 127.0.0.1
+email.notification.smtp.port = 1025
+email.notification.smtp.user = test_user
+email.notification.smtp.password = just_a_password

tracim/__init__.py

 from pyramid.config import Configurator
 from pyramid.authentication import BasicAuthAuthenticationPolicy
 from hapic.ext.pyramid import PyramidContext
+from pyramid.exceptions import NotFound
+from sqlalchemy.exc import OperationalError
 
 from tracim.extensions import hapic
 from tracim.config import CFG
 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.core_api.system_controller import SystemController
 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()
     # Add SqlAlchemy DB
     configurator.include('.models')
     # set Hapic
-    hapic.set_context(
-        PyramidContext(
-            configurator=configurator,
-            default_error_builder=ErrorSchema()
-        )
+    context = PyramidContext(
+        configurator=configurator,
+        default_error_builder=ErrorSchema(),
+        debug=app_config.DEBUG,
     )
+    hapic.set_context(context)
+    context.handle_exception(NotFound, 404)
+    context.handle_exception(OperationalError, 500)
+    context.handle_exception(Exception, 500)
     # Add controllers
     session_controller = SessionController()
     system_controller = SystemController()
         '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/__init__.py

 
 from pyramid.paster import bootstrap
 from pyramid.scripting import AppEnvironment
-from tracim.exceptions import CommandAbortedError
+from tracim.exceptions import BadCommandError
 from tracim.lib.utils.utils import DEFAULT_TRACIM_CONFIG_FILE
 
 
                 with app_context['request'].tm:
                     self.take_app_action(parsed_args, app_context)
 
+
     def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super(AppContextCommand, self).get_parser(prog_name)
 

tracim/command/user.py

 from pyramid.scripting import AppEnvironment
 import transaction
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm.exc import NoResultFound
 
 from tracim import CFG
 from tracim.command import AppContextCommand
 #from tracim.lib.daemons import DaemonsManager
 #from tracim.lib.daemons import RadicaleDaemon
 #from tracim.lib.email import get_email_manager
-from tracim.exceptions import AlreadyExistError
-from tracim.exceptions import CommandAbortedError
+from tracim.exceptions import UserAlreadyExistError, GroupDoesNotExist
+from tracim.exceptions import NotificationNotSend
+from tracim.exceptions import BadCommandError
 from tracim.lib.core.group import GroupApi
 from tracim.lib.core.user import UserApi
 from tracim.models import User
         return self._user_api.user_with_email_exists(login)
 
     def _get_group(self, name: str) -> Group:
+        groups_availables = [group.group_name
+                             for group in self._group_api.get_all()]
+        if name not in groups_availables:
+            msg = "Group '{}' does not exist, choose a group name in : ".format(name)  # nopep8
+            for group in groups_availables:
+                msg+= "'{}',".format(group)
+            self._session.rollback()
+            raise GroupDoesNotExist(msg)
         return self._group_api.get_one_with_name(name)
 
     def _add_user_to_named_group(
             user: str,
             group_name: str
     ) -> None:
+
         group = self._get_group(group_name)
         if user not in group.users:
             group.users.append(user)
             group.users.remove(user)
         self._session.flush()
 
-    def _create_user(self, login: str, password: str, **kwargs) -> User:
+    def _create_user(
+            self,
+            login: str,
+            password: str,
+            do_notify: bool,
+            **kwargs
+    ) -> User:
         if not password:
             if self._password_required():
-                raise CommandAbortedError(
+                raise BadCommandError(
                     "You must provide -p/--password parameter"
                 )
             password = ''
 
         try:
-            user = self._user_api.create_user(email=login)
-            user.password = password
-            self._user_api.save(user)
+            user = self._user_api.create_user(
+                email=login,
+                password=password,
+                do_save=True,
+                do_notify=do_notify,
+            )
             # TODO - G.M - 04-04-2018 - [Caldav] Check this code
             # # We need to enable radicale if it not already done
             # daemons = DaemonsManager()
             # daemons.run('radicale', RadicaleDaemon)
-
             self._user_api.execute_created_user_actions(user)
         except IntegrityError:
             self._session.rollback()
-            raise AlreadyExistError()
+            raise UserAlreadyExistError()
+        except NotificationNotSend as exception:
+            self._session.rollback()
+            raise exception
 
         return user
 
             try:
                 user = self._create_user(
                     login=parsed_args.login,
-                    password=parsed_args.password
+                    password=parsed_args.password,
+                    do_notify=parsed_args.send_email,
                 )
-            except AlreadyExistError:
-                raise CommandAbortedError("Error: User already exist (use `user update` command instead)")
+            except UserAlreadyExistError:
+                raise UserAlreadyExistError("Error: User already exist (use `user update` command instead)")
+            except NotificationNotSend:
+                raise NotificationNotSend("Error: Cannot send email notification, user not created.")
             # TODO - G.M - 04-04-2018 - [Email] Check this code
             # if parsed_args.send_email:
             #     email_manager = get_email_manager()
     action = UserCommand.ACTION_UPDATE
 
 
-class LDAPUserUnknown(CommandAbortedError):
+class LDAPUserUnknown(BadCommandError):
     pass

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/config.py

 from tracim.lib.utils.logger import logger
 from depot.manager import DepotManager
 
+from tracim.models.data import ActionDescription, ContentType
+
 
 class CFG(object):
     """Object used for easy access to config file parameters."""
             '604800',
         ))
 
+        self.DEBUG = asbool(settings.get('debug', False))
         # TODO - G.M - 27-03-2018 - [Email] Restore email config
         ###
         # EMAIL related stuff (notification, reply)
-        ###
-        #
-        # self.EMAIL_NOTIFICATION_NOTIFIED_EVENTS = [
-        #     # ActionDescription.COMMENT,
-        #     # ActionDescription.CREATION,
-        #     # ActionDescription.EDITION,
-        #     # ActionDescription.REVISION,
-        #     # ActionDescription.STATUS_UPDATE
-        # ]
-        #
-        # self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
-        #     # ContentType.Page,
-        #     # ContentType.Thread,
-        #     # ContentType.File,
-        #     # ContentType.Comment,
-        #     # ContentType.Folder -- Folder is skipped
-        # ]
-        # if settings.get('email.notification.from'):
-        #     raise Exception(
-        #         'email.notification.from configuration is deprecated. '
-        #         'Use instead email.notification.from.email and '
-        #         'email.notification.from.default_label.'
-        #     )
-        #
-        # self.EMAIL_NOTIFICATION_FROM_EMAIL = settings.get(
-        #     'email.notification.from.email',
-        # )
-        # self.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL = settings.get(
-        #     'email.notification.from.default_label'
-        # )
-        # self.EMAIL_NOTIFICATION_REPLY_TO_EMAIL = settings.get(
-        #     'email.notification.reply_to.email',
-        # )
-        # self.EMAIL_NOTIFICATION_REFERENCES_EMAIL = settings.get(
-        #     'email.notification.references.email'
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML = settings.get(
-        #     'email.notification.content_update.template.html',
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT = settings.get(
-        #     'email.notification.content_update.template.text',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML = settings.get(
-        #     'email.notification.created_account.template.html',
-        #     './tracim/templates/mail/created_account_body_html.mak',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT = settings.get(
-        #     'email.notification.created_account.template.text',
-        #     './tracim/templates/mail/created_account_body_text.mak',
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT = settings.get(
-        #     'email.notification.content_update.subject',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT = settings.get(
-        #     'email.notification.created_account.subject',
-        #     '[{website_title}] Created account',
-        # )
-        # self.EMAIL_NOTIFICATION_PROCESSING_MODE = settings.get(
-        #     'email.notification.processing_mode',
-        # )
-        #
+        ##
+
+        self.EMAIL_NOTIFICATION_NOTIFIED_EVENTS = [
+            ActionDescription.COMMENT,
+            ActionDescription.CREATION,
+            ActionDescription.EDITION,
+            ActionDescription.REVISION,
+            ActionDescription.STATUS_UPDATE
+        ]
+
+        self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
+            ContentType.Page,
+            ContentType.Thread,
+            ContentType.File,
+            ContentType.Comment,
+            # ContentType.Folder -- Folder is skipped
+        ]
+        if settings.get('email.notification.from'):
+            raise Exception(
+                'email.notification.from configuration is deprecated. '
+                'Use instead email.notification.from.email and '
+                'email.notification.from.default_label.'
+            )
+
+        self.EMAIL_NOTIFICATION_FROM_EMAIL = settings.get(
+            'email.notification.from.email',
+        )
+        self.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL = settings.get(
+            'email.notification.from.default_label'
+        )
+        self.EMAIL_NOTIFICATION_REPLY_TO_EMAIL = settings.get(
+            'email.notification.reply_to.email',
+        )
+        self.EMAIL_NOTIFICATION_REFERENCES_EMAIL = settings.get(
+            'email.notification.references.email'
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML = settings.get(
+            'email.notification.content_update.template.html',
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT = settings.get(
+            'email.notification.content_update.template.text',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML = settings.get(
+            'email.notification.created_account.template.html',
+            './tracim/templates/mail/created_account_body_html.mak',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT = settings.get(
+            'email.notification.created_account.template.text',
+            './tracim/templates/mail/created_account_body_text.mak',
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT = settings.get(
+            'email.notification.content_update.subject',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT = settings.get(
+            'email.notification.created_account.subject',
+            '[{website_title}] Created account',
+        )
+        self.EMAIL_NOTIFICATION_PROCESSING_MODE = settings.get(
+            'email.notification.processing_mode',
+        )
+
         self.EMAIL_NOTIFICATION_ACTIVATED = asbool(settings.get(
             'email.notification.activated',
         ))
-        # self.EMAIL_NOTIFICATION_SMTP_SERVER = settings.get(
-        #     'email.notification.smtp.server',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_PORT = settings.get(
-        #     'email.notification.smtp.port',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_USER = settings.get(
-        #     'email.notification.smtp.user',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_PASSWORD = settings.get(
-        #     'email.notification.smtp.password',
-        # )
-        # self.EMAIL_NOTIFICATION_LOG_FILE_PATH = settings.get(
-        #     'email.notification.log_file_path',
-        #     None,
-        # )
-        #
+        self.EMAIL_NOTIFICATION_SMTP_SERVER = settings.get(
+            'email.notification.smtp.server',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_PORT = settings.get(
+            'email.notification.smtp.port',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_USER = settings.get(
+            'email.notification.smtp.user',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_PASSWORD = settings.get(
+            'email.notification.smtp.password',
+        )
+        self.EMAIL_NOTIFICATION_LOG_FILE_PATH = settings.get(
+            'email.notification.log_file_path',
+            None,
+        )
+
         # self.EMAIL_REPLY_ACTIVATED = asbool(settings.get(
         #     'email.reply.activated',
         #     False,
         #         mandatory_msg.format('email.reply.lockfile_path')
         #     )
         #
-        # self.EMAIL_PROCESSING_MODE = settings.get(
-        #     'email.processing_mode',
-        #     'sync',
-        # ).upper()
-        #
-        # if self.EMAIL_PROCESSING_MODE not in (
-        #         self.CST.ASYNC,
-        #         self.CST.SYNC,
-        # ):
-        #     raise Exception(
-        #         'email.processing_mode '
-        #         'can ''be "{}" or "{}", not "{}"'.format(
-        #             self.CST.ASYNC,
-        #             self.CST.SYNC,
-        #             self.EMAIL_PROCESSING_MODE,
-        #         )
-        #     )
-        #
-        # self.EMAIL_SENDER_REDIS_HOST = settings.get(
-        #     'email.async.redis.host',
-        #     'localhost',
-        # )
-        # self.EMAIL_SENDER_REDIS_PORT = int(settings.get(
-        #     'email.async.redis.port',
-        #     6379,
-        # ))
-        # self.EMAIL_SENDER_REDIS_DB = int(settings.get(
-        #     'email.async.redis.db',
-        #     0,
-        # ))
+        self.EMAIL_PROCESSING_MODE = settings.get(
+            'email.processing_mode',
+            'sync',
+        ).upper()
+
+        if self.EMAIL_PROCESSING_MODE not in (
+                self.CST.ASYNC,
+                self.CST.SYNC,
+        ):
+            raise Exception(
+                'email.processing_mode '
+                'can ''be "{}" or "{}", not "{}"'.format(
+                    self.CST.ASYNC,
+                    self.CST.SYNC,
+                    self.EMAIL_PROCESSING_MODE,
+                )
+            )
+
+        self.EMAIL_SENDER_REDIS_HOST = settings.get(
+            'email.async.redis.host',
+            'localhost',
+        )
+        self.EMAIL_SENDER_REDIS_PORT = int(settings.get(
+            'email.async.redis.port',
+            6379,
+        ))
+        self.EMAIL_SENDER_REDIS_DB = int(settings.get(
+            'email.async.redis.db',
+            0,
+        ))
 
         ###
         # WSGIDAV (Webdav server)

tracim/exceptions.py

     pass
 
 
-class AlreadyExistError(TracimError):
+class UserAlreadyExistError(TracimError):
     pass
 
 
-class CommandError(TracimError):
-    pass
-
-
-class CommandAbortedError(CommandError):
+class BadCommandError(TracimError):
     pass
 
 
     pass
 
 
-class NotAuthentificated(TracimException):
+class NotAuthenticated(TracimException):
     pass
 
 
     pass
 
 
+class NotificationNotSend(TracimException):
+    pass
+
+
+class GroupDoesNotExist(TracimError):
+    pass
+
+
 class ContentStatusNotExist(TracimError):
     pass
 

tracim/fixtures/__init__.py

+import copy
 import transaction
 
 
         loaded = [] if loaded is None else loaded
         self._loaded = loaded
         self._session = session
-        self._config = config
+        # FIXME - G.M - 2018-06-169 - Fixture failed with email_notification
+        # activated, disable it there now. Find better way to fix this
+        # later
+        self._config = copy.copy(config)
+        self._config.EMAIL_NOTIFICATION_ACTIVATED = False
 
     def loads(self, fixtures_classes):
         for fixture_class in fixtures_classes:

tracim/fixtures/content.py

             workspace=business_workspace,
             label='Tools',
             do_save=True,
+            do_notify=False,
         )
         menu_workspace = content_api.create(
             content_type=ContentType.Folder,
             workspace=business_workspace,
             label='Menus',
             do_save=True,
+            do_notify=False,
         )
 
         dessert_folder = content_api.create(
             workspace=recipe_workspace,
             label='Desserts',
             do_save=True,
+            do_notify=False,
         )
         salads_folder = content_api.create(
             content_type=ContentType.Folder,
             workspace=recipe_workspace,
             label='Salads',
             do_save=True,
+            do_notify=False,
         )
         other_folder = content_api.create(
             content_type=ContentType.Folder,
             workspace=other_workspace,
             label='Infos',
             do_save=True,
+            do_notify=False,
         )
 
         # Pages, threads, ..
             parent=dessert_folder,
             label='Tiramisu Recipe',
             do_save=True,
+            do_notify=False,
         )
         best_cake_thread = content_api.create(
             content_type=ContentType.Thread,
             parent=dessert_folder,
             label='Best Cakes ?',
             do_save=False,
+            do_notify=False,
         )
         best_cake_thread.description = 'What is the best cake ?'
         self._session.add(best_cake_thread)
             parent=dessert_folder,
             label='Apple_Pie',
             do_save=False,
+            do_notify=False,
         )
         apple_pie_recipe.file_extension = '.txt'
         apple_pie_recipe.depot_file = FileIntent(
             parent=dessert_folder,
             label='Brownie Recipe',
             do_save=False,
+            do_notify=False,
         )
         Brownie_recipe.file_extension = '.html'
         Brownie_recipe.depot_file = FileIntent(
             parent=fruits_desserts_folder,
             label='Fruit Salad',
             do_save=True,
+            do_notify=False,
         )
         with new_revision(
                 session=self._session,
             parent=fruits_desserts_folder,
             label='Bad Fruit Salad',
             do_save=True,
+            do_notify=False,
         )
         with new_revision(
                 session=self._session,

tracim/lib/core/content.py

 
         return result
 
-    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False) -> Content:
+    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False, do_notify=True) -> Content:
         assert content_type in ContentType.allowed_types()
 
         if content_type == ContentType.Folder and not label:
 
         if do_save:
             self._session.add(content)
-            self.save(content, ActionDescription.CREATION)
+            self.save(content, ActionDescription.CREATION, do_notify=do_notify)
         return content
 
 
         :return:
         """
         NotifierFactory.create(
-            self._config,
-            self._user
+            config=self._config,
+            current_user=self._user,
+            session=self._session,
         ).notify_content_update(content)
 
     def get_keywords(self, search_string, search_string_separators=None) -> [str]:

tracim/lib/core/group.py

 # -*- coding: utf-8 -*-
 import typing
 
+from sqlalchemy.orm.exc import NoResultFound
+
+from tracim.exceptions import GroupDoesNotExist
 from tracim import CFG
 
+
 __author__ = 'damien'
 
 from tracim.models.auth import Group, User
         return self._session.query(Group)
 
     def get_one(self, group_id) -> Group:
-        return self._base_query().filter(Group.group_id == group_id).one()
+        try:
+            group = self._base_query().filter(Group.group_id == group_id).one()
+            return group
+        except NoResultFound:
+            raise GroupDoesNotExist()
 
     def get_one_with_name(self, group_name) -> Group:
-        return self._base_query().filter(Group.group_name == group_name).one()
+        try:
+            group = self._base_query().filter(Group.group_name == group_name).one()
+            return group
+        except NoResultFound:
+            raise GroupDoesNotExist()
+
+    def get_all(self):
+        return self._base_query().order_by(Group.group_id).all()

tracim/lib/core/notifications.py

 # -*- coding: utf-8 -*-
+from sqlalchemy.orm import Session
 
+from tracim import CFG
 from tracim.lib.utils.logger import logger
 from tracim.models.auth import User
 from tracim.models.data import Content
     """
     Interface for Notifier instances
     """
-    def __init__(self, config, current_user: User=None):
+    def __init__(self,
+                 config: CFG,
+                 session: Session,
+                 current_user: User=None,
+    ) -> None:
         pass
 
     def notify_content_update(self, content: Content):
 class NotifierFactory(object):
 
     @classmethod
-    def create(cls, config, current_user: User=None) -> INotifier:
+    def create(cls, config, session, current_user: User=None) -> INotifier:
         if not config.EMAIL_NOTIFICATION_ACTIVATED:
-            return DummyNotifier(config, current_user)
-        return EmailNotifier(config, current_user)
+            return DummyNotifier(config, session, current_user)
+        from tracim.lib.mail_notifier.notifier import EmailNotifier
+        return EmailNotifier(config, session, current_user)
 
 
 class DummyNotifier(INotifier):
     send_count = 0
 
-    def __init__(self, config, current_user: User=None):
-        INotifier.__init__(config, current_user)
+    def __init__(
+            self,
+            config: CFG,
+            session: Session,
+            current_user: User=None
+    ) -> None:
+        INotifier.__init__(
+            self,
+            config,
+            session,
+            current_user,
+        )
         logger.info(self, 'Instantiating Dummy Notifier')
 
     def notify_content_update(self, content: Content):
             self,
             'Fake notifier, do not send notification for update of content {}'.format(content.content_id)  # nopep8
         )
-
-
-class EmailNotifier(INotifier):
-    # TODO - G.M [emailNotif] move and restore Email Notifier in another file.
-    pass

tracim/lib/core/user.py

 # -*- coding: utf-8 -*-
 import threading
+from smtplib import SMTPException
 
 import transaction
 import typing as typing
 
+from tracim.exceptions import NotificationNotSend
+from tracim.lib.mail_notifier.notifier import get_email_manager
 from sqlalchemy.orm import Session
 
 from tracim import CFG
             user: User,
             name: str=None,
             email: str=None,
-            do_save=True,
+            password: str=None,
             timezone: str='',
+            do_save=True,
     ) -> None:
         if name is not None:
             user.display_name = name
         if email is not None:
             user.email = email
 
+        if password is not None:
+            user.password = password
+
         user.timezone = timezone
 
         if do_save:
             self.save(user)
 
-    def create_user(self, email=None, groups=[], save_now=False) -> User:
+    def create_user(
+        self,
+        email,
+        password: str = None,
+        name: str = None,
+        timezone: str = '',
+        groups=[],
+        do_save: bool=True,
+        do_notify: bool=True,
+    ) -> User:
+        new_user = self.create_minimal_user(email, groups, save_now=False)
+        self.update(
+            user=new_user,
+            name=name,
+            email=email,
+            password=password,
+            timezone=timezone,
+            do_save=False,
+        )
+        if do_notify:
+            try:
+                email_manager = get_email_manager(self._config, self._session)
+                email_manager.notify_created_account(
+                    new_user,
+                    password=password
+                )
+            except SMTPException as e:
+                raise NotificationNotSend()
+        if do_save:
+            self.save(new_user)
+        return new_user
+
+    def create_minimal_user(
+            self,
+            email,
+            groups=[],
+            save_now=False
+    ) -> User:
+        """Previous create_user method"""
         user = User()
 
-        if email:
-            user.email = email
+        user.email = email
 
         for group in groups:
             user.groups.append(group)

tracim/lib/core/userworkspace.py

         """
         Return WorkspaceInContext object from Workspace
         """
+        assert self._config
         workspace = UserRoleWorkspaceInContext(
             user_role=user_role,
             dbsession=self._session,
         workspace:Workspace
     ) -> typing.List[UserRoleInWorkspace]:
         return self._session.query(UserRoleInWorkspace)\
-            .filter(UserRoleInWorkspace.workspace_id == workspace.workspace_id).all()  # nopep8
+            .filter(UserRoleInWorkspace.workspace_id==workspace.workspace_id)\
+            .all()
 
     def save(self, role: UserRoleInWorkspace) -> None:
         self._session.flush()

tracim/lib/mail_notifier/daemon.py

+from sqlalchemy.orm import collections
+
+from tracim.lib.utils.logger import logger
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.lib.utils.utils import get_redis_connection
+from rq.dummy import do_nothing
+from rq.worker import StopRequested
+from rq import Connection as RQConnection
+from rq import Worker as BaseRQWorker
+
+
+class FakeDaemon(object):
+    """
+    Temporary class for transition between tracim 1 and tracim 2
+    """
+    def __init__(self, config, *args, **kwargs):
+        pass
+
+
+class MailSenderDaemon(FakeDaemon):
+    # NOTE: use *args and **kwargs because parent __init__ use strange
+    # * parameter
+    def __init__(self, config, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.config = config
+        self.worker = None  # type: RQWorker
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        logger.warning('MailSenderDaemon not implement append_thread_callback')
+        pass
+
+    def stop(self) -> None:
+        # When _stop_requested at False, tracim.lib.daemons.RQWorker
+        # will raise StopRequested exception in worker thread after receive a
+        # job.
+        self.worker._stop_requested = True
+        redis_connection = get_redis_connection(self.config)
+        queue = get_rq_queue(redis_connection, 'mail_sender')
+        queue.enqueue(do_nothing)
+
+    def run(self) -> None:
+
+        with RQConnection(get_redis_connection(self.config)):
+            self.worker = RQWorker(['mail_sender'])
+            self.worker.work()
+
+
+class RQWorker(BaseRQWorker):
+    def _install_signal_handlers(self):
+        # RQ Worker is designed to work in main thread
+        # So we have to disable these signals (we implement server stop in
+        # MailSenderDaemon.stop method).
+        pass
+
+    def dequeue_job_and_maintain_ttl(self, timeout):
+        # RQ Worker is designed to work in main thread, so we add behaviour
+        # here: if _stop_requested has been set to True, raise the standard way
+        # StopRequested exception to stop worker.
+        if self._stop_requested:
+            raise StopRequested()
+        return super().dequeue_job_and_maintain_ttl(timeout)

tracim/lib/mail_notifier/notifier.py

+# -*- coding: utf-8 -*-
+import datetime
+import typing
+
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.utils import formataddr
+
+from lxml.html.diff import htmldiff
+from mako.template import Template
+from sqlalchemy.orm import Session
+
+from tracim import CFG
+from tracim.lib.core.notifications import INotifier
+from tracim.lib.mail_notifier.sender import EmailSender
+from tracim.lib.mail_notifier.utils import SmtpConfiguration, EST
+from tracim.lib.mail_notifier.sender import send_email_through
+from tracim.lib.core.workspace import WorkspaceApi
+from tracim.lib.utils.logger import logger
+from tracim.models import User
+from tracim.models.auth import User
+from tracim.models.data import ActionDescription
+from tracim.models.data import Content
+from tracim.models.data import ContentType
+from tracim.models.data import UserRoleInWorkspace
+from tracim.lib.utils.translation import fake_translator as l_, \
+    fake_translator as _
+
+
+class EmailNotifier(INotifier):
+    """
+    EmailNotifier, this class will decide how to notify by mail
+    in order to let a EmailManager create email
+    """
+
+    def __init__(
+            self,
+            config: CFG,
+            session: Session,
+            current_user: User=None
+    ):
+        """
+        :param current_user: the user that has triggered the notification
+        :return:
+        """
+        INotifier.__init__(self, config, session, current_user)
+        logger.info(self, 'Instantiating Email Notifier')
+
+        self._user = current_user
+        self.session = session
+        self.config = config
+        self._smtp_config = SmtpConfiguration(
+            self.config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+
+    def notify_content_update(self, content: Content):
+
+        if content.get_last_action().id not \
+                in self.config.EMAIL_NOTIFICATION_NOTIFIED_EVENTS:
+            logger.info(
+                self,
+                'Skip email notification for update of content {}'
+                'by user {} (the action is {})'.format(
+                    content.content_id,
+                    # below: 0 means "no user"
+                    self._user.user_id if self._user else 0,
+                    content.get_last_action().id
+                )
+            )
+            return
+
+        logger.info(self,
+                    'About to email-notify update'
+                    'of content {} by user {}'.format(
+                        content.content_id,
+                        # Below: 0 means "no user"
+                        self._user.user_id if self._user else 0
+                    )
+        )
+
+        if content.type not \
+                in self.config.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS:
+            logger.info(
+                self,
+                'Skip email notification for update of content {}'
+                'by user {} (the content type is {})'.format(
+                    content.type,
+                    # below: 0 means "no user"
+                    self._user.user_id if self._user else 0,
+                    content.get_last_action().id
+                )
+            )
+            return
+
+        logger.info(self,
+                    'About to email-notify update'
+                    'of content {} by user {}'.format(
+                        content.content_id,
+                        # Below: 0 means "no user"
+                        self._user.user_id if self._user else 0
+                    )
+        )
+
+        ####
+        #
+        # INFO - D.A. - 2014-11-05 - Emails are sent through asynchronous jobs.
+        # For that reason, we do not give SQLAlchemy objects but ids only
+        # (SQLA objects are related to a given thread/session)
+        #
+        try:
+            if self.config.EMAIL_NOTIFICATION_PROCESSING_MODE.lower() == self.config.CST.ASYNC.lower():
+                logger.info(self, 'Sending email in ASYNC mode')
+                # TODO - D.A - 2014-11-06
+                # This feature must be implemented in order to be able to scale to large communities
+                raise NotImplementedError('Sending emails through ASYNC mode is not working yet')
+            else:
+                logger.info(self, 'Sending email in SYNC mode')
+                EmailManager(
+                    self._smtp_config,
+                    self.config,
+                    self.session,
+                ).notify_content_update(self._user.user_id, content.content_id)
+        except TypeError as e:
+            logger.error(self, 'Exception catched during email notification: {}'.format(e.__str__()))
+
+
+class EmailManager(object):
+    """
+    Compared to Notifier, this class is independant from the HTTP request thread
+    This class will build Email and send it for both created account and content
+    update
+    """
+
+    def __init__(
+            self,
+            smtp_config: SmtpConfiguration,
+            config: CFG,
+            session: Session
+    ) -> None:
+        self._smtp_config = smtp_config
+        self.config = config
+        self.session = session
+        # FIXME - G.M - We need to have a session for the emailNotifier
+
+        # if not self.session:
+        #     engine = get_engine(settings)
+        #     session_factory = get_session_factory(engine)
+        #     app_config = CFG(settings)
+
+    def _get_sender(self, user: User=None) -> str:
+        """
+        Return sender string like "Bob Dylan
+            (via Tracim) <notification@mail.com>"
+        :param user: user to extract display name
+        :return: sender string
+        """
+
+        email_template = self.config.EMAIL_NOTIFICATION_FROM_EMAIL
+        mail_sender_name = self.config.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL  # nopep8
+        if user:
+            mail_sender_name = '{name} via Tracim'.format(name=user.display_name)
+            email_address = email_template.replace('{user_id}', str(user.user_id))
+            # INFO - D.A. - 2017-08-04
+            # We use email_template.replace() instead of .format() because this
+            # method is more robust to errors in config file.
+            #
+            # For example, if the email is info+{userid}@tracim.fr
+            # email.format(user_id='bob') will raise an exception
+            # email.replace('{user_id}', 'bob') will just ignore {userid}
+        else:
+            email_address = email_template.replace('{user_id}', '0')
+
+        return formataddr((mail_sender_name, email_address))
+
+    # Content Notification
+
+    @staticmethod
+    def log_notification(
+            config: CFG,
+            action: str,
+            recipient: typing.Optional[str],
+            subject: typing.Optional[str],
+    ) -> None:
+        """Log notification metadata."""
+        log_path = config.EMAIL_NOTIFICATION_LOG_FILE_PATH
+        if log_path:
+            # TODO - A.P - 2017-09-06 - file logging inefficiency
+            # Updating a document with 100 users to notify will leads to open
+            # and close the file 100 times.
+            with open(log_path, 'a') as log_file:
+                print(
+                    datetime.datetime.now(),
+                    action,
+                    recipient,
+                    subject,
+                    sep='|',
+                    file=log_file,
+                )
+
+    def notify_content_update(
+            self,
+            event_actor_id: int,
+            event_content_id: int
+    ) -> None:
+        """
+        Look for all users to be notified about the new content and send them an
+        individual email
+        :param event_actor_id: id of the user that has triggered the event
+        :param event_content_id: related content_id
+        :return:
+        """
+        # FIXME - D.A. - 2014-11-05
+        # Dirty import. It's here in order to avoid circular import
+        from tracim.lib.core.content import ContentApi
+        from tracim.lib.core.user import UserApi
+        user = UserApi(
+            None,
+            config=self.config,
+            session=self.session,
+            ).get_one(event_actor_id)
+        logger.debug(self, 'Content: {}'.format(event_content_id))
+        content_api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.config,
+            )
+        content = ContentApi(
+            session=self.session,
+            current_user=user, # TODO - use a system user instead of the user that has triggered the event
+            config=self.config,
+            show_archived=True,
+            show_deleted=True,
+        ).get_one(event_content_id, ContentType.Any)
+        main_content = content.parent if content.type == ContentType.Comment else content
+        notifiable_roles = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.config,
+        ).get_notifiable_roles(content.workspace)
+
+        if len(notifiable_roles) <= 0:
+            logger.info(self, 'Skipping notification as nobody subscribed to in workspace {}'.format(content.workspace.label))
+            return
+
+
+        logger.info(self, 'Sending asynchronous emails to {} user(s)'.format(len(notifiable_roles)))
+        # INFO - D.A. - 2014-11-06
+        # The following email sender will send emails in the async task queue
+        # This allow to build all mails through current thread but really send them (including SMTP connection)
+        # In the other thread.
+        #
+        # This way, the webserver will return sooner (actually before notification emails are sent
+        async_email_sender = EmailSender(
+            self.config,
+            self._smtp_config,
+            self.config.EMAIL_NOTIFICATION_ACTIVATED
+        )
+        for role in notifiable_roles:
+            logger.info(self, 'Sending email to {}'.format(role.user.email))
+            to_addr = formataddr((role.user.display_name, role.user.email))
+            #
+            # INFO - G.M - 2017-11-15 - set content_id in header to permit reply
+            # references can have multiple values, but only one in this case.
+            replyto_addr = self.config.EMAIL_NOTIFICATION_REPLY_TO_EMAIL.replace( # nopep8
+                '{content_id}',str(content.content_id)
+            )
+
+            reference_addr = self.config.EMAIL_NOTIFICATION_REFERENCES_EMAIL.replace( #nopep8
+                '{content_id}',str(content.content_id)
+             )
+            #
+            #  INFO - D.A. - 2014-11-06
+            # We do not use .format() here because the subject defined in the .ini file
+            # may not include all required labels. In order to avoid partial format() (which result in an exception)
+            # we do use replace and force the use of .__str__() in order to process LazyString objects
+            #
+            subject = self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT
+            subject = subject.replace(EST.WEBSITE_TITLE, self.config.WEBSITE_TITLE.__str__())
+            subject = subject.replace(EST.WORKSPACE_LABEL, main_content.workspace.label.__str__())
+            subject = subject.replace(EST.CONTENT_LABEL, main_content.label.__str__())
+            subject = subject.replace(EST.CONTENT_STATUS_LABEL, main_content.get_status().label.__str__())
+            reply_to_label = l_('{username} & all members of {workspace}').format(
+                username=user.display_name,
+                workspace=main_content.workspace.label)
+
+            message = MIMEMultipart('alternative')
+            message['Subject'] = subject
+            message['From'] = self._get_sender(user)
+            message['To'] = to_addr
+            message['Reply-to'] = formataddr((reply_to_label, replyto_addr))
+            # INFO - G.M - 2017-11-15
+            # References can theorically have label, but in pratice, references
+            # contains only message_id from parents post in thread.
+            # To link this email to a content we create a virtual parent
+            # in reference who contain the content_id.
+            message['References'] = formataddr(('',reference_addr))
+            body_text = self._build_email_body_for_content(self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT, role, content, user)
+            body_html = self._build_email_body_for_content(self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML, role, content, user)
+
+            part1 = MIMEText(body_text, 'plain', 'utf-8')
+            part2 = MIMEText(body_html, 'html', 'utf-8')
+            # Attach parts into message container.
+            # According to RFC 2046, the last part of a multipart message, in this case
+            # the HTML message, is best and preferred.
+            message.attach(part1)
+            message.attach(part2)
+
+            self.log_notification(
+                action='CREATED',
+                recipient=message['To'],
+                subject=message['Subject'],
+                config=self.config,
+            )
+
+            send_email_through(
+                self.config,
+                async_email_sender.send_mail,
+                message
+            )
+
+    def notify_created_account(
+            self,
+            user: User,
+            password: str,
+    ) -> None:
+        """
+        Send created account email to given user.
+
+        :param password: choosed password
+        :param user: user to notify
+        """
+        # TODO BS 20160712: Cyclic import
+        logger.debug(self, 'user: {}'.format(user.user_id))
+        logger.info(self, 'Sending asynchronous email to 1 user ({0})'.format(
+            user.email,
+        ))
+
+        async_email_sender = EmailSender(
+            self.config,
+            self._smtp_config,
+            self.config.EMAIL_NOTIFICATION_ACTIVATED
+        )
+
+        subject = \
+            self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT \
+            .replace(
+                EST.WEBSITE_TITLE,
+                self.config.WEBSITE_TITLE.__str__()
+            )
+        message = MIMEMultipart('alternative')
+        message['Subject'] = subject
+        message['From'] = self._get_sender()
+        message['To'] = formataddr((user.get_display_name(), user.email))
+
+        text_template_file_path = self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT  # nopep8
+        html_template_file_path = self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML  # nopep8
+
+        context = {
+            'user': user,
+            'password': password,
+            # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for logo_url  # nopep8
+            'logo_url': '',
+            # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for login_url  # nopep8
+            'login_url': self.config.WEBSITE_BASE_URL,
+        }
+        body_text = self._render_template(
+            mako_template_filepath=text_template_file_path,
+            context=context
+        )
+
+        body_html = self._render_template(
+            mako_template_filepath=html_template_file_path,
+            context=context,
+        )
+
+        part1 = MIMEText(body_text, 'plain', 'utf-8')
+        part2 = MIMEText(body_html, 'html', 'utf-8')
+
+        # Attach parts into message container.
+        # According to RFC 2046, the last part of a multipart message,
+        # in this case the HTML message, is best and preferred.
+        message.attach(part1)
+        message.attach(part2)
+
+        send_email_through(
+            config=self.config,
+            sendmail_callable=async_email_sender.send_mail,
+            message=message
+        )
+
+    def _render_template(
+            self,
+            mako_template_filepath: str,
+            context: dict
+    ) -> str:
+        """
+        Render mako template with all needed current variables.
+
+        :param mako_template_filepath: file path of mako template
+        :param context: dict with template context
+        :return: template rendered string
+        """
+
+        template = Template(filename=mako_template_filepath)
+        return template.render(
+            _=_,
+            config=self.config,
+            **context
+        )
+
+    def _build_email_body_for_content(
+            self,
+            mako_template_filepath: str,
+            role: UserRoleInWorkspace,
+            content: Content,
+            actor: User
+    ) -> str:
+        """
+        Build an email body and return it as a string
+        :param mako_template_filepath: the absolute path to the mako template to be used for email body building
+        :param role: the role related to user to whom the email must be sent. The role is required (and not the user only) in order to show in the mail why the user receive the notification
+        :param content: the content item related to the notification
+        :param actor: the user at the origin of the action / notification (for example the one who wrote a comment
+        :param config: the global configuration
+        :return: the built email body as string. In case of multipart email, this method must be called one time for text and one time for html
+        """
+        logger.debug(self, 'Building email content from MAKO template {}'.format(mako_template_filepath))
+
+        main_title = content.label
+        content_intro = ''
+        content_text = ''
+        call_to_action_text = ''
+
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for call_to_action_url  # nopep8
+        call_to_action_url =''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for status_icon_url  # nopep8
+        status_icon_url = ''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for workspace_url  # nopep8
+        workspace_url = ''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for logo_url  # nopep8
+        logo_url = ''
+
+        action = content.get_last_action().id
+        if ActionDescription.COMMENT == action:
+            content_intro = l_('<span id="content-intro-username">{}</span> added a comment:').format(actor.display_name)
+            content_text = content.description
+            call_to_action_text = l_('Answer')
+
+        elif ActionDescription.CREATION == action:
+
+            # Default values (if not overriden)
+            content_text = content.description
+            call_to_action_text = l_('View online')
+
+            if ContentType.Thread == content.type:
+                call_to_action_text = l_('Answer')
+                content_intro = l_('<span id="content-intro-username">{}</span> started a thread entitled:').format(actor.display_name)
+                content_text = '<p id="content-body-intro">{}</p>'.format(content.label) + \
+                               content.get_last_comment_from(actor).description
+
+            elif ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> added a file entitled:').format(actor.display_name)
+                if content.description:
+                    content_text = content.description
+                else:
+                    content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
+
+            elif ContentType.Page == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> added a page entitled:').format(actor.display_name)
+                content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
+
+        elif ActionDescription.REVISION == action:
+            content_text = content.description
+            call_to_action_text = l_('View online')
+
+            if ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> uploaded a new revision.').format(actor.display_name)
+                content_text = ''
+
+            elif ContentType.Page == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
+                previous_revision = content.get_previous_revision()
+                title_diff = ''
+                if previous_revision.label != content.label:
+                    title_diff = htmldiff(previous_revision.label, content.label)
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
+                    title_diff + \
+                    htmldiff(previous_revision.description, content.description)
+
+            elif ContentType.Thread == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the thread description.').format(actor.display_name)
+                previous_revision = content.get_previous_revision()
+                title_diff = ''
+                if previous_revision.label != content.label:
+                    title_diff = htmldiff(previous_revision.label, content.label)
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
+                    title_diff + \
+                    htmldiff(previous_revision.description, content.description)
+
+        elif ActionDescription.EDITION == action:
+            call_to_action_text = l_('View online')
+
+            if ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the file description.').format(actor.display_name)
+                content_text = '<p id="content-body-intro">{}</p>'.format(content.get_label()) + \
+                    content.description
+
+        elif ActionDescription.STATUS_UPDATE == action:
+            call_to_action_text = l_('View online')
+            intro_user_msg = l_(
+                '<span id="content-intro-username">{}</span> '
+                'updated the following status:'
+            )
+            content_intro = intro_user_msg.format(actor.display_name)
+            intro_body_msg = '<p id="content-body-intro">{}: {}</p>'
+            content_text = intro_body_msg.format(
+                content.get_label(),
+                content.get_status().label,
+            )
+
+        if '' == content_intro and content_text == '':
+            # Skip notification, but it's not normal
+            logger.error(
+                self, 'A notification is being sent but no content. '
+                      'Here are some debug informations: [content_id: {cid}]'
+                      '[action: {act}][author: {actor}]'.format(
+                    cid=content.content_id, act=action, actor=actor
+                )
+            )
+            raise ValueError('Unexpected empty notification')
+
+        context = {
+            'user': role.user,
+            'workspace': role.workspace,
+            'workspace_url': workspace_url,
+            'main_title': main_title,
+            'status_label': content.get_status().label,
+            'status_icon_url': status_icon_url,
+            'role_label': role.role_as_label(),
+            'content_intro': content_intro,
+            'content_text': content_text,
+            'call_to_action_text': call_to_action_text,
+            'call_to_action_url': call_to_action_url,
+            'logo_url': logo_url,
+        }
+        user = role.user
+        workspace = role.workspace
+        body_content = self._render_template(
+            mako_template_filepath=mako_template_filepath,
+            context=context,
+        )
+        return body_content
+
+
+def get_email_manager(config: CFG, session: Session):
+    """
+    :return: EmailManager instance
+    """
+    #  TODO: Find a way to import properly without cyclic import
+
+    smtp_config = SmtpConfiguration(
+        config.EMAIL_NOTIFICATION_SMTP_SERVER,
+        config.EMAIL_NOTIFICATION_SMTP_PORT,
+        config.EMAIL_NOTIFICATION_SMTP_USER,
+        config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+    )
+
+    return EmailManager(config=config, smtp_config=smtp_config, session=session)

tracim/lib/mail_notifier/sender.py

+# -*- coding: utf-8 -*-
+import smtplib
+import typing
+from email.message import Message
+from email.mime.multipart import MIMEMultipart
+
+from tracim.config import CFG
+from tracim.lib.utils.logger import logger
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.lib.utils.utils import get_redis_connection
+from tracim.lib.mail_notifier.utils import SmtpConfiguration
+
+def send_email_through(
+        config: CFG,
+        sendmail_callable: typing.Callable[[Message], None],
+        message: Message,
+) -> None:
+    """
+    Send mail encapsulation to send it in async or sync mode.
+
+    TODO BS 20170126: A global mail/sender management should be a good
+                      thing. Actually, this method is an fast solution.
+    :param config: system configuration
+    :param sendmail_callable: A callable who get message on first parameter
+    :param message: The message who have to be sent
+    """
+
+    if config.EMAIL_PROCESSING_MODE == config.CST.SYNC:
+        sendmail_callable(message)
+    elif config.EMAIL_PROCESSING_MODE == config.CST.ASYNC:
+        redis_connection = get_redis_connection(config)
+        queue = get_rq_queue(redis_connection, 'mail_sender')
+        queue.enqueue(sendmail_callable, message)
+    else:
+        raise NotImplementedError(
+            'Mail sender processing mode {} is not implemented'.format(
+                config.EMAIL_PROCESSING_MODE,
+            )
+        )
+
+
+class EmailSender(object):
+    """
+    Independent email sender class.
+
+    To allow its use in any thread, as an asyncjob_perform() call for
+    example, it has no dependencies on SQLAlchemy nor tg HTTP request.
+    """
+
+    def __init__(
+            self,
+            config: CFG,
+            smtp_config: SmtpConfiguration,
+            really_send_messages
+    ) -> None:
+        self._smtp_config = smtp_config
+        self.config = config
+        self._smtp_connection = None
+        self._is_active = really_send_messages
+
+    def connect(self):
+        if not self._smtp_connection:
+            log = 'Connecting from SMTP server {}'
+            logger.info(self, log.format(self._smtp_config.server))
+            self._smtp_connection = smtplib.SMTP(
+                self._smtp_config.server,
+                self._smtp_config.port
+            )
+            self._smtp_connection.ehlo()
+
+            if self._smtp_config.login:
+                try:
+                    starttls_result = self._smtp_connection.starttls()
+                    log = 'SMTP start TLS result: {}'
+                    logger.debug(self, log.format(starttls_result))
+                except Exception as e:
+                    log = 'SMTP start TLS error: {}'
+                    logger.debug(self, log.format(e.__str__()))
+
+            if self._smtp_config.login:
+                try:
+                    login_res = self._smtp_connection.login(
+                        self._smtp_config.login,
+                        self._smtp_config.password
+                    )
+                    log = 'SMTP login result: {}'
+                    logger.debug(self, log.format(login_res))
+                except Exception as e:
+                    log = 'SMTP login error: {}'
+                    logger.debug(self, log.format(e.__str__()))
+            logger.info(self, 'Connection OK')
+
+    def disconnect(self):
+        if self._smtp_connection:
+            log = 'Disconnecting from SMTP server {}'
+            logger.info(self, log.format(self._smtp_config.server))
+            self._smtp_connection.quit()
+            logger.info(self, 'Connection closed.')
+
+    def send_mail(self, message: MIMEMultipart):
+        if not self._is_active:
+            log = 'Not sending email to {} (service disabled)'
+            logger.info(self, log.format(message['To']))
+        else:
+            self.connect()  # Actually, this connects to SMTP only if required
+            logger.info(self, 'Sending email to {}'.format(message['To']))
+            self._smtp_connection.send_message(message)
+            from tracim.lib.mail_notifier.notifier import EmailManager
+            EmailManager.log_notification(
+                action='   SENT',
+                recipient=message['To'],
+                subject=message['Subject'],
+                config=self.config,
+            )

tracim/lib/mail_notifier/utils.py

+class SmtpConfiguration(object):
+    """Container class for SMTP configuration used in Tracim."""
+
+    def __init__(self, server: str, port: int, login: str, password: str):
+        self.server = server
+        self.port = port
+        self.login = login
+        self.password = password
+
+
+class EST(object):
+    """
+    EST = Email Subject Tags - this is a convenient class - no business logic
+    here
+    This class is intended to agregate all dynamic content that may be included
+    in email subjects
+    """
+
+    WEBSITE_TITLE = '{website_title}'
+    WORKSPACE_LABEL = '{workspace_label}'
+    CONTENT_LABEL = '{content_label}'
+    CONTENT_STATUS_LABEL = '{content_status_label}'
+
+    @classmethod
+    def all(cls):
+        return [
+            cls.CONTENT_LABEL,
+            cls.CONTENT_STATUS_LABEL,
+            cls.WEBSITE_TITLE,
+            cls.WORKSPACE_LABEL
+        ]
+
+

tracim/lib/utils/authentification.py

         if not login:
             return None
         user = uapi.get_one_by_email(login)
-    except (NoResultFound, UserDoesNotExist):
+    except UserDoesNotExist:
         return None
     return user

tracim/lib/utils/authorization.py

 # We prefer to use decorators
 
 
-def require_same_user_or_profile(group):
+def require_same_user_or_profile(group: int):
     """
     Decorator for view to restrict access of tracim request if candidate user
     is distinct from authenticated user and not with high enough profile.
     return decorator
 
 
-def require_profile(group):
+def require_profile(group: int):
     """
     Decorator for view to restrict access of tracim request if profile is
     not high enough
     return decorator
 
 
-def require_workspace_role(minimal_required_role):
+def require_workspace_role(minimal_required_role: int):
     """
     Decorator for view to restrict access of tracim request if role
     is not high enough

tracim/lib/utils/request.py

 from sqlalchemy.orm.exc import NoResultFound
 
 
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import UserNotFoundInTracimRequest
 from tracim.exceptions import UserDoesNotExist
 from tracim.exceptions import WorkspaceNotFound
         )
         # Current workspace, found by request headers or content
         self._current_workspace = None  # type: Workspace
+
         # Authenticated user
         self._current_user = None  # type: User
+
         # User found from request headers, content, distinct from authenticated
         # user
         self._user_candidate = None  # type: User
+
         # INFO - G.M - 18-05-2018 - Close db at the end of the request
         self.add_finished_callback(self._cleanup)
 
             raise UserNotFoundInTracimRequest('You request a current user but the context not permit to found one')  # nopep8
         user = uapi.get_one_by_email(login)
     except (UserDoesNotExist, UserNotFoundInTracimRequest) as exc:
-        raise NotAuthentificated('User {} not found'.format(login)) from exc
+        raise NotAuthenticated('User {} not found'.format(login)) from exc
     return user
 
 
         if 'workspace_id' in request.matchdict:
             workspace_id = request.matchdict['workspace_id']
         if not workspace_id:
-            raise WorkspaceNotFound('No workspace_id param')
+            raise WorkspaceNotFound('No workspace_id property found in request')
         wapi = WorkspaceApi(
             current_user=user,
             session=request.dbsession,

tracim/lib/utils/utils.py

 # -*- coding: utf-8 -*-
 import datetime
+from redis import Redis
+from rq import Queue
+
+from tracim.config import CFG
 
 DEFAULT_WEBDAV_CONFIG_FILE = "wsgidav.conf"
 DEFAULT_TRACIM_CONFIG_FILE = "development.ini"
 
 
+def get_redis_connection(config: CFG) -> Redis:
+    """
+    :param config: current app_config
+    :return: redis connection
+    """
+    return Redis(
+        host=config.EMAIL_SENDER_REDIS_HOST,
+        port=config.EMAIL_SENDER_REDIS_PORT,
+        db=config.EMAIL_SENDER_REDIS_DB,
+    )
+
+
+def get_rq_queue(redis_connection: Redis, queue_name: str ='default') -> Queue:
+    """
+    :param queue_name: name of queue
+    :return: wanted queue
+    """
+
+    return Queue(name=queue_name, connection=redis_connection)
+
+
 def cmp_to_key(mycmp):
     """
     List sort related function

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/design.py

                     <td>%s</td>
                 </tr>
                 ''' % ('warning' if event.id == content_revision.revision_id else '',
-                       event.type.icon,
+                       event.type.fa_icon,
                        label,
                        date,
                        event.owner.display_name,
                         </div>
                     </div>
                     ''' % ('warning' if t.id == content_revision.revision_id else '',
-                           t.type.icon,
+                           t.type.fa_icon,
                            t.owner.display_name,
                            t.create_readable_date(),
                            label,

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/models/applications.py

             self,
             label: str,
             slug: str,
-            icon: str,
+            fa_icon: str,
             hexcolor: str,
             is_active: bool,
             config: typing.Dict[str, str],
             main_route: str,
     ) -> None:
+        """
+        @param label: public label of application
+        @param slug: identifier of application
+        @param icon: font awesome icon class
+        @param hexcolor: hexa color of application main color
+        @param is_active: True if application enable, False if inactive
+        @param config: a dict with eventual application config
+        @param main_route: the route of the frontend "home" screen of
+        the application. For exemple, if you have an application
+        called "calendar", the main route will be something
+        like /#/workspace/{wid}/calendar.
+        """
         self.label = label
         self.slug = slug
-        self.icon = icon
+        self.fa_icon = fa_icon
         self.hexcolor = hexcolor
         self.is_active = is_active
         self.config = config
 calendar = Application(
     label='Calendar',
     slug='calendar',
-    icon='calendar-alt',
+    fa_icon='calendar-alt',
     hexcolor='#757575',
     is_active=True,
     config={},
 thread = Application(
     label='Threads',
     slug='contents/threads',
-    icon='comments-o',
+    fa_icon='comments-o',
     hexcolor='#ad4cf9',
     is_active=True,
     config={},
 
 )
 
-file = Application(
+_file = Application(
     label='Files',
     slug='contents/files',
-    icon='paperclip',
+    fa_icon='paperclip',
     hexcolor='#FF9900',
     is_active=True,
     config={},
 markdownpluspage = Application(
     label='Markdown Plus Documents',  # TODO - G.M - 24-05-2018 - Check label
     slug='contents/markdownpluspage',
-    icon='file-code',
+    fa_icon='file-code',
     hexcolor='#f12d2d',
     is_active=True,
     config={},
 htmlpage = Application(
     label='Text Documents',  # TODO - G.M - 24-05-2018 - Check label
     slug='contents/htmlpage',
-    icon='file-text-o',
+    fa_icon='file-text-o',
     hexcolor='#3f52e3',
     is_active=True,
     config={},
 applications = [
     htmlpage,
     markdownpluspage,
-    file,
+    _file,
     thread,
     calendar,
 ]

tracim/models/contents.py

 from enum import Enum
 
 from tracim.exceptions import ContentStatusNotExist, ContentTypeNotExist
-from tracim.models.applications import htmlpage, file, thread, markdownpluspage
+from tracim.models.applications import htmlpage, _file, thread, markdownpluspage
 
 
 ####
             slug: str,
             global_status: str,
             label: str,
-            icon: str,
+            fa_icon: str,
             hexcolor: str,
     ):
         self.slug = slug
         self.global_status = global_status
         self.label = label
-        self.icon = icon
+        self.fa_icon = fa_icon
         self.hexcolor = hexcolor
 
 
     slug='open',
     global_status=GlobalStatus.OPEN.value,
     label='Open',
-    icon='fa-square-o',
+    fa_icon='fa-square-o',
     hexcolor='#000FF',
 )
 
     slug='closed-validated',
     global_status=GlobalStatus.CLOSED.value,
     label='Validated',
-    icon='fa-check-square-o',
+    fa_icon='fa-check-square-o',
     hexcolor='#000FF',
 )
 
     slug='closed-unvalidated',
     global_status=GlobalStatus.CLOSED.value,
     label='Cancelled',
-    icon='fa-close',
+    fa_icon='fa-close',
     hexcolor='#000FF',
 )
 
     slug='closed-deprecated',
     global_status=GlobalStatus.CLOSED.value,
     label='Deprecated',
-    icon='fa-warning',
+    fa_icon='fa-warning',
     hexcolor='#000FF',
 )
 
                     slug=status.slug,
                     global_status=status.global_status,
                     label=status.label,
-                    icon=status.icon,
+                    fa_icon=status.fa_icon,
                     hexcolor=status.hexcolor,
                 )
                 return
     def __init__(
             self,
             slug: str,
-            icon: str,
+            fa_icon: str,
             hexcolor: str,
             label: str,
             creation_label: str,
 
     ):
         self.slug = slug
-        self.icon = icon
+        self.fa_icon = fa_icon
         self.hexcolor = hexcolor
         self.label = label
         self.creation_label = creation_label
 
 thread_type = NewContentType(
     slug='thread',
-    icon=thread.icon,
+    fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Thread',
     creation_label='Discuss about a topic',
 
 file_type = NewContentType(
     slug='file',
-    icon=file.icon,
-    hexcolor=file.hexcolor,
+    fa_icon=_file.fa_icon,
+    hexcolor=_file.hexcolor,
     label='File',
     creation_label='Upload a file',
     available_statuses=CONTENT_DEFAULT_STATUS,
 
 markdownpluspage_type = NewContentType(
     slug='markdownpage',
-    icon=markdownpluspage.icon,
+    fa_icon=markdownpluspage.fa_icon,
     hexcolor=markdownpluspage.hexcolor,
     label='Rich Markdown File',
     creation_label='Create a Markdown document',
 
 htmlpage_type = NewContentType(
     slug='page',
-    icon=htmlpage.icon,
+    fa_icon=htmlpage.fa_icon,
     hexcolor=htmlpage.hexcolor,
     label='Text Document',
     creation_label='Write a document',
 # TODO - G.M - 31-05-2018 - Set Better folder params
 folder_type = NewContentType(
     slug='folder',
-    icon=thread.icon,
+    fa_icon=thread.fa_icon,
     hexcolor=thread.hexcolor,
     label='Folder',
     creation_label='Create collection of any documents',
             if slug == content_type.slug:
                 super(ContentTypeLegacy, self).__init__(
                     slug=content_type.slug,
-                    icon=content_type.icon,
+                    fa_icon=content_type.fa_icon,
                     hexcolor=content_type.hexcolor,
                     label=content_type.label,
                     creation_label=content_type.creation_label,

tracim/models/data.py

         WORKSPACE_MANAGER: 'workspace_manager',
     }
 
-    # LABEL = dict()
-    # LABEL[0] = l_('N/A')
-    # LABEL[1] = l_('Reader')
-    # LABEL[2] = l_('Contributor')
-    # LABEL[4] = l_('Content Manager')
-    # LABEL[8] = l_('Workspace Manager')
+    LABEL = dict()
+    LABEL[0] = l_('N/A')
+    LABEL[1] = l_('Reader')
+    LABEL[2] = l_('Contributor')
+    LABEL[4] = l_('Content Manager')
+    LABEL[8] = l_('Workspace Manager')
     #
     # STYLE = dict()
     # STYLE[0] = ''
     #
     #
     # @property
-    # def icon(self):
+    # def fa_icon(self):
     #     return UserRoleInWorkspace.ICON[self.role]
     #
     # @property
     # def style(self):
     #     return UserRoleInWorkspace.STYLE[self.role]
     #
-    # def role_as_label(self):
-    #     return UserRoleInWorkspace.LABEL[self.role]
+
+    def role_as_label(self):
+        return UserRoleInWorkspace.LABEL[self.role]
 
     @classmethod
     def get_all_role_values(cls) -> typing.List[int]:
     def __init__(self, role_id):
         self.role_type_id = role_id
         # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
-        # self.icon = UserRoleInWorkspace.ICON[role_id]
+        # self.fa_icon = UserRoleInWorkspace.ICON[role_id]
         # self.role_label = UserRoleInWorkspace.LABEL[role_id]
         # self.css_style = UserRoleInWorkspace.STYLE[role_id]
 
     def __init__(self, id):
         assert id in ActionDescription.allowed_values()
         self.id = id
-        # FIXME - G.M - 17-04-2018 - Label and icon needed for webdav
+        # FIXME - G.M - 17-04-2018 - Label and fa_icon needed for webdav
         #  design template,
         # find a way to not rely on this.
         self.label = self.id
-        self.icon = ActionDescription._ICONS[id]
+        self.fa_icon = ActionDescription._ICONS[id]
+        #self.icon = self.fa_icon
         # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
         # self.label = ActionDescription._LABELS[id]
 
                 ]
 
 
-from .contents import ContentStatusLegacy as ContentStatus
-from .contents import ContentTypeLegacy as ContentType
+from tracim.models.contents import ContentStatusLegacy as ContentStatus
+from tracim.models.contents import ContentTypeLegacy as ContentType
 # TODO - G.M - 30-05-2018 - Drop this old code when whe are sure nothing
 # is lost .
 
         assert hasattr(type, 'id')
         # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
         # assert hasattr(type, 'css')
-        # assert hasattr(type, 'icon')
+        # assert hasattr(type, 'fa_icon')
         # assert hasattr(type, 'label')
 
     def created_as_delta(self, delta_from_datetime:datetime=None):

tracim/models/workspace_menu_entries.py

             self,
             label: str,
             slug: str,
-            icon: str,
+            fa_icon: str,
             hexcolor: str,
             route: str,
     ) -> None:
         self.label = label
         self.route = route
         self.hexcolor = hexcolor
-        self.icon = icon
+        self.fa_icon = fa_icon
 
 dashboard_menu_entry = WorkspaceMenuEntry(
   slug='dashboard',
   label='Dashboard',
   route='/#/workspaces/{workspace_id}/dashboard',
   hexcolor='#252525',
-  icon="",
+  fa_icon="",
 )
 all_content_menu_entry = WorkspaceMenuEntry(
   slug="contents/all",
   label="All Contents",
   route="/#/workspaces/{workspace_id}/contents",
   hexcolor="#fdfdfd",
-  icon="",
+  fa_icon="",
 )
 
 # TODO - G.M - 08-06-2018 - This is hardcoded default menu entry,
                 slug=app.slug,
                 label=app.label,
                 hexcolor=app.hexcolor,
-                icon=app.icon,
+                fa_icon=app.fa_icon,
                 route=app.main_route
             )
             menu_entries.append(new_entry)

tracim/templates/mail/content_update_body_html.mak

+## -*- coding: utf-8 -*-
+<html>
+  <head>
+    <style>
+      a { color: #3465af;}
+      a.call-to-action {
+        background: #3465af;
+        padding: 3px 4px 5px 4px;
+        border: 1px solid #12438d;
+        font-weight: bold;
+        color: #FFF;
+        text-decoration: none;
+        margin-left: 5px;
+      }
+      a.call-to-action img { vertical-align: middle;}
+      th { vertical-align: top;}
+      
+      #content-intro-username { font-size: 1.5em; color: #666; font-weight: bold; }
+      #content-intro { margin: 0; border: 1em solid #DDD; border-width: 0 0 0 0em; padding: 1em 1em 1em 1em; }
+      #content-body { margin: 0em; border: 2em solid #DDD; border-width: 0 0 0 4em; padding: 0.5em 2em 1em 1em; }
+      #content-body-intro { font-size: 2em; color: #666; }
+      #content-body-only-title { font-size: 1.5em; }
+
+      #content-body ins { background-color: #AFA; }
+      #content-body del { background-color: #FAA; }
+
+
+      #call-to-action-button { background-color: #5CB85C; border: 1px solid #4CAE4C; color: #FFF; text-decoration: none; font-weight: bold; border-radius: 3px; font-size: 2em; padding: 4px 0.3em;}
+      #call-to-action-container { text-align: right; margin-top: 2em; }
+
+      #footer hr { border: 0px solid #CCC; border-top-width: 1px; width: 8em; max-width:25%; margin-left: 0;}
+      #footer { color: #999; margin: 4em auto auto 0.5em; }
+      #footer a { color: #999; }
+    </style>
+  </head>
+  <body style="font-family: Arial; font-size: 12px; max-width: 600px; margin: 0; padding: 0;">
+
+    <table style="width: 100%; cell-padding: 0; border-collapse: collapse; margin: 0">
+      <tr style="background-color: F5F5F5; border-bottom: 1px solid #CCC;" >
+        <td style="background-color: #666;">
+            <img alt="logo" src="${logo_url}" style="vertical-align: middle;">
+        </td>
+        <td style="padding: 0.5em; background-color: #666; text-align: left;">
+          <span style="font-size: 1.3em; color: #FFF; font-weight: bold;">
+            ${main_title}
+            &mdash;&nbsp;<span style="font-weight: bold; color: #999; font-weight: bold;">
+              ${status_label|n}
+              <img alt="status_icon" src="${status_icon_url}" style="vertical-align: middle;">
+            </span>
+        </td>
+      </tr>
+    </table>
+
+    <p id="content-intro">${content_intro|n}</p>
+    <div id="content-body">
+        <div>${content_text|n}</div>
+        <div href='' id="call-to-action-container">
+        </div>
+    </div>
+    
+    <div id="footer">
+        <p>
+
+            ${_('{user_display_name}, you receive this email because you are registered on <i>{website_title}</i> and you are <i>{user_role_label}</i> in the workspace <a href="{workspace_url}">{workspace_label}</a>.').format(user_display_name=user.display_name, user_role_label=role_label, workspace_url=workspace_url, workspace_label=workspace.label, website_title=config.WEBSITE_TITLE)|n}
+        </p>
+        <hr/>
+        <p>
+            ${_('This email was automatically sent by <i>Tracim</i>, a collaborative software developped by Algoo.')}<br/>
+            Algoo SAS &mdash; 340 Rue de l'Eygala, 38430 Moirans, France &mdash; <a style="text-decoration: none;" href="http://algoo.fr">www.algoo.fr</a>
+        </p>
+    </div>
+  </body>
+</html>

tracim/templates/mail/content_update_body_text.mak

+## -*- coding: utf-8 -*-
+
+Dear ${user.display_name},
+
+This email is intended to be read as HTML content.
+Please configure your email client to get the best of Tracim notifications.
+
+We understand that Email was originally intended to carry raw text only.
+And you probably understand on your own that we are a decades after email
+was created ;)
+
+Hope you'll switch your mail client configuration and enjoy Tracim :)
+
+
+--------------------------------------------------------------------------------
+
+
+You receive this email because you are registered on /${config.WEBSITE_TITLE}/
+and you are /${role_label}/ in the workspace /${workspace.label}/
+
+----
+
+This email was automatically sent by *Tracim*,
+a collaborative software developped by Algoo.
+
+**Algoo SAS**
+340 Rue de l'Eygala
+38430 Moirans
+France
+http://algoo.fr
+

tracim/templates/mail/created_account_body_html.mak

+## -*- coding: utf-8 -*-
+<html>
+  <head>
+    <style>
+      a { color: #3465af;}
+      a.call-to-action {
+        background: #3465af;
+        padding: 3px 4px 5px 4px;
+        border: 1px solid #12438d;
+        font-weight: bold;
+        color: #FFF;
+        text-decoration: none;
+        margin-left: 5px;
+      }
+      a.call-to-action img { vertical-align: middle;}
+      th { vertical-align: top;}
+      
+      #content-intro-username { font-size: 1.5em; color: #666; font-weight: bold; }
+      #content-intro { margin: 0; border: 1em solid #DDD; border-width: 0 0 0 0em; padding: 1em 1em 1em 1em; }
+      #content-body { margin: 0em; border: 2em solid #DDD; border-width: 0 0 0 4em; padding: 0.5em 2em 1em 1em; }
+      #content-body-intro { font-size: 2em; color: #666; }
+      #content-body-only-title { font-size: 1.5em; }
+
+      #content-body ins { background-color: #AFA; }
+      #content-body del { background-color: #FAA; }
+
+
+      #call-to-action-button { background-color: #5CB85C; border: 1px solid #4CAE4C; color: #FFF; text-decoration: none; font-weight: bold; border-radius: 3px; font-size: 2em; padding: 4px 0.3em;}
+      #call-to-action-container { text-align: right; margin-top: 2em; }
+
+      #footer hr { border: 0px solid #CCC; border-top-width: 1px; width: 8em; max-width:25%; margin-left: 0;}
+      #footer { color: #999; margin: 4em auto auto 0.5em; }
+      #footer a { color: #999; }
+    </style>
+  </head>
+  <body style="font-family: Arial; font-size: 12px; max-width: 600px; margin: 0; padding: 0;">
+
+    <table style="width: 100%; cell-padding: 0; border-collapse: collapse; margin: 0">
+      <tr style="background-color: F5F5F5; border-bottom: 1px solid #CCC;" >
+        <td style="background-color: #666;">
+            <img alt="logo" src="${logo_url}" style="vertical-align: middle;">
+        </td>
+        <td style="padding: 0.5em; background-color: #666; text-align: left;">
+          <span style="font-size: 1.3em; color: #FFF; font-weight: bold;">
+
+            ${config.WEBSITE_TITLE}: ${_('Created account')}
+
+          </span>
+        </td>
+      </tr>
+    </table>
+
+    <div id="content-body">
+        <div>
+            ${_('An administrator just create account for you on {website_title}'.format(
+                website_title=config.WEBSITE_TITLE
+            ))}
+
+            <ul>
+                <li>
+                    <b>${_('Login')}</b>: ${user.email}
+                </li>
+                <li>
+                    <b>${_('Password')}</b>: ${password}
+                </li>
+            </ul>
+
+        </div>
+        <div id="call-to-action-container">
+
+            ${_('To go to {website_title}, please click on following link'.format(
+                website_title=config.WEBSITE_TITLE
+            ))}
+
+            <span style="">
+                <a href="${login_url}" id='call-to-action-button'>${login_url}</a>
+            </span>
+        </div>
+    </div>
+    
+    <div id="footer">
+        <p>
+            ${_('This email was sent by <i>Tracim</i>, a collaborative software developped by Algoo.')}<br/>
+            Algoo SAS &mdash; 340 Rue de l'Eygala, 38430 Moirans, France &mdash; <a style="text-decoration: none;" href="http://algoo.fr">www.algoo.fr</a>
+        </p>
+    </div>
+  </body>
+</html>

tracim/templates/mail/created_account_body_text.mak

+## -*- coding: utf-8 -*-
+
+${_('An administrator just create account for you on {website_title}'.format(
+    website_title=config.WEBSITE_TITLE
+))}
+
+* ${_('Login')}: ${user.email}
+* ${_('Password')}: ${password}
+
+${_('To go to {website_title}, please click on following link'.format(
+    website_title=config.WEBSITE_TITLE
+))}
+
+${login_url}
+
+--------------------------------------------------------------------------------
+
+This email was sent by *Tracim*,
+a collaborative software developped by Algoo.
+
+**Algoo SAS**
+340 Rue de l'Eygala
+38430 Moirans
+France
+http://algoo.fr

tracim/tests/__init__.py

 # -*- coding: utf-8 -*-
 import unittest
+
+import plaster
+import requests
 import transaction
 from depot.manager import DepotManager
 from pyramid import testing
 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
 
 
     sqlalchemy_url = 'sqlite:///tracim_test.sqlite'
 
     def setUp(self):
+        logger._logger.setLevel('WARNING')
         DepotManager._clear()
-        settings = {
+        self.settings = {
             'sqlalchemy.url': self.sqlalchemy_url,
             'user.auth_token.validity': '604800',
             'depot_storage_dir': '/tmp/test/depot',
 
         }
         hapic.reset_context()
-        app = main({}, **settings)
-        self.init_database(settings)
+        self.engine = get_engine(self.settings)
+        DeclarativeBase.metadata.create_all(self.engine)
+        self.session_factory = get_session_factory(self.engine)
+        self.app_config = CFG(self.settings)
+        self.app_config.configure_filedepot()
+        self.init_database(self.settings)
+        DepotManager._clear()
+        self.run_app()
+
+    def run_app(self):
+        app = web({}, **self.settings)
         self.testapp = TestApp(app)
 
     def init_database(self, settings):
-        self.engine = get_engine(settings)
-        DeclarativeBase.metadata.create_all(self.engine)
-        session_factory = get_session_factory(self.engine)
-        app_config = CFG(settings)
         with transaction.manager:
-            dbsession = get_tm_session(session_factory, transaction.manager)
+            dbsession = get_tm_session(self.session_factory, transaction.manager)
             try:
-                fixtures_loader = FixturesLoader(dbsession, app_config)
+                fixtures_loader = FixturesLoader(dbsession, self.app_config)
                 fixtures_loader.loads(self.fixtures)
                 transaction.commit()
                 print("Database initialized.")
         self.engine = get_engine(settings)
 
 
+class CommandFunctionalTest(FunctionalTest):
+
+    def run_app(self):
+        self.session = get_tm_session(self.session_factory, transaction.manager)
+
+
 class BaseTest(unittest.TestCase):
     """
     Pyramid default test.
     """
 
+    config_uri = 'tests_configs.ini'
+    config_section = 'base_test'
+
     def setUp(self):
+        logger._logger.setLevel('WARNING')
         logger.debug(self, 'Setup Test...')
-        self.config = testing.setUp(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',
-
-        })
+        self.settings = plaster.get_settings(
+            self.config_uri,
+            self.config_section
+        )
+        self.config = testing.setUp(settings = self.settings)
         self.config.include('tracim.models')
         DepotManager._clear()
         DepotManager.configure(
             owner=user
         )
         return thread
+
+
+class MailHogTest(DefaultTest):
+    """
+    Theses test need a working mailhog
+    """
+
+    config_section = 'mail_test'
+
+    def tearDown(self):
+        logger.debug(self, 'Cleanup MailHog list...')
+        requests.delete('http://127.0.0.1:8025/api/v1/messages')

tracim/tests/commands/test_commands.py

 # -*- coding: utf-8 -*-
 import os
 import subprocess
-
+import pytest
 import tracim
+from tracim.command import TracimCLI
+from tracim.exceptions import UserAlreadyExistError
+from tracim.exceptions import BadCommandError
+from tracim.exceptions import GroupDoesNotExist
+from tracim.exceptions import UserDoesNotExist
+from tracim.lib.core.user import UserApi
+from tracim.tests import CommandFunctionalTest
+
 
+class TestCommands(CommandFunctionalTest):
+    """
+    Test tracimcli command line ui.
+    """
 
-class TestCommands(object):
-    def test_commands(self):
+    config_section = 'app:command_test'
+
+    def test_func__check_commands_list__ok__nominal_case(self) -> None:
         """
         Test listing of tracimcli command: Tracim commands must be listed
         :return:
         assert output.find('user update') > 0
         assert output.find('db init') > 0
         assert output.find('db delete') > 0
+        assert output.find('webdav start') > 0
+
+    def test_func__user_create_command__ok__nominal_case(self) -> None:
+        """
+        Test User creation
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(UserDoesNotExist):
+            api.get_one_by_email('command_test@user')
+        app = TracimCLI()
+        result = app.run([
+            'user', 'create',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'command_test@user',
+            '-p', 'new_password',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('command_test@user')
+        assert new_user.email == 'command_test@user'
+        assert new_user.validate_password('new_password')
+        assert new_user.profile.name == 'users'
+
+    def test_func__user_create_command__ok__in_admin_group(self) -> None:
+        """
+        Test User creation with admin as group
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(UserDoesNotExist):
+            api.get_one_by_email('command_test@user')
+        app = TracimCLI()
+        result = app.run([
+            'user', 'create',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'command_test@user',
+            '-p', 'new_password',
+            '-g', 'administrators',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('command_test@user')
+        assert new_user.email == 'command_test@user'
+        assert new_user.validate_password('new_password')
+        assert new_user.profile.name == 'administrators'
+
+    def test_func__user_create_command__err__in_unknown_group(self) -> None:
+        """
+        Test User creation with an unknown group
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(GroupDoesNotExist):
+            result = app.run([
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'command_test@user',
+                '-p', 'new_password',
+                '-g', 'unknown',
+                '--debug',
+            ])
+
+    def test_func__user_create_command__err_user_already_exist(self) -> None:
+        """
+        Test User creation with existing user login
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(UserAlreadyExistError):
+            result = app.run([
+                '--debug',
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'admin@admin.admin',
+                '-p', 'new_password',
+                '--debug',
+            ])
+
+    def test_func__user_create_command__err__password_required(self) -> None:
+        """
+        Test User creation without filling password
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(BadCommandError):
+            result = app.run([
+                '--debug',
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'admin@admin.admin',
+                '--debug',
+            ])
+
+    def test_func__user_update_command__ok__nominal_case(self) -> None:
+        """
+        Test user password update
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        user = api.get_one_by_email('admin@admin.admin')
+        assert user.email == 'admin@admin.admin'
+        assert user.validate_password('admin@admin.admin')
+        assert not user.validate_password('new_password')
+
+        app = TracimCLI()
+        result = app.run([
+            'user', 'update',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'admin@admin.admin',
+            '-p', 'new_password',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('admin@admin.admin')
+        assert new_user.email == 'admin@admin.admin'
+        assert new_user.validate_password('new_password')
+        assert not new_user.validate_password('admin@admin.admin')
+
+    def test_func__user_update_command__ok__remove_group(self) -> None:
+        """
+        Test user password update
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        user = api.get_one_by_email('admin@admin.admin')
+        assert user.email == 'admin@admin.admin'
+        assert user.validate_password('admin@admin.admin')
+        assert not user.validate_password('new_password')
+        assert user.profile.name == 'administrators'
+        app = TracimCLI()
+        result = app.run([
+            'user', 'update',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'admin@admin.admin',
+            '-p', 'new_password',
+            '-rmg', 'administrators',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('admin@admin.admin')
+        assert new_user.email == 'admin@admin.admin'
+        assert new_user.validate_password('new_password')
+        assert not new_user.validate_password('admin@admin.admin')
+        assert new_user.profile.name == 'managers'

tracim/tests/functional/test_mail_notification.py

+# coding=utf-8
+# INFO - G.M - 09-06-2018 - Those test need a working MailHog
+
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+import requests
+from rq import SimpleWorker
+
+from tracim.fixtures.users_and_groups import Base as BaseFixture
+from tracim.fixtures.content import Content as ContentFixture
+from tracim.lib.utils.utils import get_redis_connection
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.models.data import ContentType
+
+from tracim.lib.core.content import ContentApi
+from tracim.lib.core.user import UserApi
+from tracim.lib.core.workspace import WorkspaceApi
+from tracim.lib.mail_notifier.sender import EmailSender
+from tracim.lib.mail_notifier.utils import SmtpConfiguration
+from tracim.tests import MailHogTest
+
+
+class TestEmailSender(MailHogTest):
+
+    def test__func__connect_disconnect__ok__nominal_case(self):
+        smtp_config = SmtpConfiguration(
+            self.app_config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+        sender = EmailSender(
+            self.app_config,
+            smtp_config,
+            True,
+        )
+        sender.connect()
+        sender.disconnect()
+
+    def test__func__send_email__ok__nominal_case(self):
+        smtp_config = SmtpConfiguration(
+            self.app_config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+        sender = EmailSender(
+            self.app_config,
+            smtp_config,
+            True,
+        )
+
+        # Create test_mail
+        msg = MIMEMultipart()
+        msg['Subject'] = 'test__func__send_email__ok__nominal_case'
+        msg['From'] = 'test_send_mail@localhost'
+        msg['To'] = 'receiver_test_send_mail@localhost'
+        text = "test__func__send_email__ok__nominal_case"
+        html = """\
+        <html>
+          <head></head>
+          <body>
+            <p>test__func__send_email__ok__nominal_case</p>
+          </body>
+        </html>
+        """.replace(' ', '').replace('\n', '')
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(html, 'html')
+        msg.attach(part1)
+        msg.attach(part2)
+
+        sender.send_mail(msg)
+        sender.disconnect()
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'test_send_mail@localhost'
+        assert headers['To'][0] == 'receiver_test_send_mail@localhost'
+        assert headers['Subject'][0] == 'test__func__send_email__ok__nominal_case'  # nopep8
+        assert response[0]['MIME']['Parts'][0]['Body'] == text
+        assert response[0]['MIME']['Parts'][1]['Body'] == html
+
+
+class TestNotificationsSync(MailHogTest):
+
+    fixtures = [BaseFixture, ContentFixture]
+
+    def test_func__create_user_with_mail_notification__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=True,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'Tracim Notifications <test_user_from+0@localhost>'  # nopep8
+        assert headers['To'][0] == 'bob <bob@bob>'
+        assert headers['Subject'][0] == '[TRACIM] Created account'
+
+    def test_func__create_new_content_with_notification__ok__nominal_case(self):
+        uapi = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        current_user = uapi.get_one_by_email('admin@admin.admin')
+        # Create new user with notification enabled on w1 workspace
+        wapi = WorkspaceApi(
+            current_user=current_user,
+            session=self.session,
+            config=self.app_config,
+        )
+        workspace = wapi.get_one_by_label('Recipes')
+        user = uapi.get_one_by_email('bob@fsf.local')
+        wapi.enable_notifications(user, workspace)
+
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        item = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'parent',
+            do_save=True,
+            do_notify=False,
+        )
+        item2 = api.create(
+            ContentType.File,
+            workspace,
+            item,
+            'file1',
+            do_save=True,
+            do_notify=True,
+        )
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == '"Bob i. via Tracim" <test_user_from+3@localhost>'  # nopep8
+        assert headers['To'][0] == 'Global manager <admin@admin.admin>'
+        assert headers['Subject'][0] == '[TRACIM] [Recipes] file1 (Open)'
+        assert headers['References'][0] == 'test_user_refs+19@localhost'
+        assert headers['Reply-to'][0] == '"Bob i. & all members of Recipes" <test_user_reply+19@localhost>'  # nopep8
+
+
+class TestNotificationsAsync(MailHogTest):
+    fixtures = [BaseFixture, ContentFixture]
+    config_section = 'mail_test_async'
+
+    def test_func__create_user_with_mail_notification__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=True,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
+
+        # Send mail async from redis queue
+        redis = get_redis_connection(
+            self.app_config
+        )
+        queue = get_rq_queue(
+            redis,
+            'mail_sender',
+        )
+        worker = SimpleWorker([queue], connection=queue.connection)
+        worker.work(burst=True)
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'Tracim Notifications <test_user_from+0@localhost>'  # nopep8
+        assert headers['To'][0] == 'bob <bob@bob>'
+        assert headers['Subject'][0] == '[TRACIM] Created account'
+
+    def test_func__create_new_content_with_notification__ok__nominal_case(self):
+        uapi = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        current_user = uapi.get_one_by_email('admin@admin.admin')
+        # Create new user with notification enabled on w1 workspace
+        wapi = WorkspaceApi(
+            current_user=current_user,
+            session=self.session,
+            config=self.app_config,
+        )
+        workspace = wapi.get_one_by_label('Recipes')
+        user = uapi.get_one_by_email('bob@fsf.local')
+        wapi.enable_notifications(user, workspace)
+
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        item = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'parent',
+            do_save=True,
+            do_notify=False,
+        )
+        item2 = api.create(
+            ContentType.File,
+            workspace,
+            item,
+            'file1',
+            do_save=True,
+            do_notify=True,
+        )
+        # Send mail async from redis queue
+        redis = get_redis_connection(
+            self.app_config
+        )
+        queue = get_rq_queue(
+            redis,
+            'mail_sender',
+        )
+        worker = SimpleWorker([queue], connection=queue.connection)
+        worker.work(burst=True)
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == '"Bob i. via Tracim" <test_user_from+3@localhost>'  # nopep8
+        assert headers['To'][0] == 'Global manager <admin@admin.admin>'
+        assert headers['Subject'][0] == '[TRACIM] [Recipes] file1 (Open)'
+        assert headers['References'][0] == 'test_user_refs+19@localhost'
+        assert headers['Reply-to'][0] == '"Bob i. & all members of Recipes" <test_user_reply+19@localhost>'  # nopep8

tracim/tests/functional/test_session.py

 
 class TestLoginEndpointUnititedDB(FunctionalTestNoDB):
 
-    @pytest.mark.xfail(raises=OperationalError,
-                       reason='Not supported yet by hapic')
     def test_api__try_login_enpoint__err_500__no_inited_db(self):
         params = {
             'email': 'admin@admin.admin',

tracim/tests/functional/test_system.py

         application = res[0]
         assert application['label'] == "Text Documents"
         assert application['slug'] == 'contents/htmlpage'
-        assert application['icon'] == 'file-text-o'
+        assert application['fa_icon'] == 'file-text-o'
         assert application['hexcolor'] == '#3f52e3'
         assert application['is_active'] is True
         assert 'config' in application
         application = res[1]
         assert application['label'] == "Markdown Plus Documents"
         assert application['slug'] == 'contents/markdownpluspage'
-        assert application['icon'] == 'file-code'
+        assert application['fa_icon'] == 'file-code'
         assert application['hexcolor'] == '#f12d2d'
         assert application['is_active'] is True
         assert 'config' in application
         application = res[2]
         assert application['label'] == "Files"
         assert application['slug'] == 'contents/files'
-        assert application['icon'] == 'paperclip'
+        assert application['fa_icon'] == 'paperclip'
         assert application['hexcolor'] == '#FF9900'
         assert application['is_active'] is True
         assert 'config' in application
         application = res[3]
         assert application['label'] == "Threads"
         assert application['slug'] == 'contents/threads'
-        assert application['icon'] == 'comments-o'
+        assert application['fa_icon'] == 'comments-o'
         assert application['hexcolor'] == '#ad4cf9'
         assert application['is_active'] is True
         assert 'config' in application
         application = res[4]
         assert application['label'] == "Calendar"
         assert application['slug'] == 'calendar'
-        assert application['icon'] == 'calendar-alt'
+        assert application['fa_icon'] == 'calendar-alt'
         assert application['hexcolor'] == '#757575'
         assert application['is_active'] is True
         assert 'config' in application
 
         content_type = res[0]
         assert content_type['slug'] == 'thread'
-        assert content_type['icon'] == 'comments-o'
+        assert content_type['fa_icon'] == 'comments-o'
         assert content_type['hexcolor'] == '#ad4cf9'
         assert content_type['label'] == 'Thread'
         assert content_type['creation_label'] == 'Discuss about a topic'
 
         content_type = res[1]
         assert content_type['slug'] == 'file'
-        assert content_type['icon'] == 'paperclip'
+        assert content_type['fa_icon'] == 'paperclip'
         assert content_type['hexcolor'] == '#FF9900'
         assert content_type['label'] == 'File'
         assert content_type['creation_label'] == 'Upload a file'
 
         content_type = res[2]
         assert content_type['slug'] == 'markdownpage'
-        assert content_type['icon'] == 'file-code'
+        assert content_type['fa_icon'] == 'file-code'
         assert content_type['hexcolor'] == '#f12d2d'
         assert content_type['label'] == 'Rich Markdown File'
         assert content_type['creation_label'] == 'Create a Markdown document'
 
         content_type = res[3]
         assert content_type['slug'] == 'page'
-        assert content_type['icon'] == 'file-text-o'
+        assert content_type['fa_icon'] == 'file-text-o'
         assert content_type['hexcolor'] == '#3f52e3'
         assert content_type['label'] == 'Text Document'
         assert content_type['creation_label'] == 'Write a document'

tracim/tests/functional/test_user.py

         assert sidebar_entry['label'] == 'Dashboard'
         assert sidebar_entry['route'] == '/#/workspaces/1/dashboard'  # nopep8
         assert sidebar_entry['hexcolor'] == "#252525"
-        assert sidebar_entry['icon'] == ""
+        assert sidebar_entry['fa_icon'] == ""
 
         sidebar_entry = workspace['sidebar_entries'][1]
         assert sidebar_entry['slug'] == 'contents/all'
         assert sidebar_entry['label'] == 'All Contents'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents"  # nopep8
         assert sidebar_entry['hexcolor'] == "#fdfdfd"
-        assert sidebar_entry['icon'] == ""
+        assert sidebar_entry['fa_icon'] == ""
 
         sidebar_entry = workspace['sidebar_entries'][2]
         assert sidebar_entry['slug'] == 'contents/htmlpage'
         assert sidebar_entry['label'] == 'Text Documents'
         assert sidebar_entry['route'] == '/#/workspaces/1/contents?type=htmlpage'  # nopep8
         assert sidebar_entry['hexcolor'] == "#3f52e3"
-        assert sidebar_entry['icon'] == "file-text-o"
+        assert sidebar_entry['fa_icon'] == "file-text-o"
 
         sidebar_entry = workspace['sidebar_entries'][3]
         assert sidebar_entry['slug'] == 'contents/markdownpluspage'
         assert sidebar_entry['label'] == 'Markdown Plus Documents'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=markdownpluspage"    # nopep8
         assert sidebar_entry['hexcolor'] == "#f12d2d"
-        assert sidebar_entry['icon'] == "file-code"
+        assert sidebar_entry['fa_icon'] == "file-code"
 
         sidebar_entry = workspace['sidebar_entries'][4]
         assert sidebar_entry['slug'] == 'contents/files'
         assert sidebar_entry['label'] == 'Files'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=file"  # nopep8
         assert sidebar_entry['hexcolor'] == "#FF9900"
-        assert sidebar_entry['icon'] == "paperclip"
+        assert sidebar_entry['fa_icon'] == "paperclip"
 
         sidebar_entry = workspace['sidebar_entries'][5]
         assert sidebar_entry['slug'] == 'contents/threads'
         assert sidebar_entry['label'] == 'Threads'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=thread"  # nopep8
         assert sidebar_entry['hexcolor'] == "#ad4cf9"
-        assert sidebar_entry['icon'] == "comments-o"
+        assert sidebar_entry['fa_icon'] == "comments-o"
 
         sidebar_entry = workspace['sidebar_entries'][6]
         assert sidebar_entry['slug'] == 'calendar'
         assert sidebar_entry['label'] == 'Calendar'
         assert sidebar_entry['route'] == "/#/workspaces/1/calendar"  # nopep8
         assert sidebar_entry['hexcolor'] == "#757575"
-        assert sidebar_entry['icon'] == "calendar-alt"
+        assert sidebar_entry['fa_icon'] == "calendar-alt"
 
     def test_api__get_user_workspaces__err_403__unallowed_user(self):
         """

tracim/tests/functional/test_workspaces.py

         assert sidebar_entry['label'] == 'Dashboard'
         assert sidebar_entry['route'] == '/#/workspaces/1/dashboard'  # nopep8
         assert sidebar_entry['hexcolor'] == "#252525"
-        assert sidebar_entry['icon'] == ""
+        assert sidebar_entry['fa_icon'] == ""
 
         sidebar_entry = workspace['sidebar_entries'][1]
         assert sidebar_entry['slug'] == 'contents/all'
         assert sidebar_entry['label'] == 'All Contents'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents"  # nopep8
         assert sidebar_entry['hexcolor'] == "#fdfdfd"
-        assert sidebar_entry['icon'] == ""
+        assert sidebar_entry['fa_icon'] == ""
 
         sidebar_entry = workspace['sidebar_entries'][2]
         assert sidebar_entry['slug'] == 'contents/htmlpage'
         assert sidebar_entry['label'] == 'Text Documents'
         assert sidebar_entry['route'] == '/#/workspaces/1/contents?type=htmlpage'  # nopep8
         assert sidebar_entry['hexcolor'] == "#3f52e3"
-        assert sidebar_entry['icon'] == "file-text-o"
+        assert sidebar_entry['fa_icon'] == "file-text-o"
 
         sidebar_entry = workspace['sidebar_entries'][3]
         assert sidebar_entry['slug'] == 'contents/markdownpluspage'
         assert sidebar_entry['label'] == 'Markdown Plus Documents'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=markdownpluspage"    # nopep8
         assert sidebar_entry['hexcolor'] == "#f12d2d"
-        assert sidebar_entry['icon'] == "file-code"
+        assert sidebar_entry['fa_icon'] == "file-code"
 
         sidebar_entry = workspace['sidebar_entries'][4]
         assert sidebar_entry['slug'] == 'contents/files'
         assert sidebar_entry['label'] == 'Files'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=file"  # nopep8
         assert sidebar_entry['hexcolor'] == "#FF9900"
-        assert sidebar_entry['icon'] == "paperclip"
+        assert sidebar_entry['fa_icon'] == "paperclip"
 
         sidebar_entry = workspace['sidebar_entries'][5]
         assert sidebar_entry['slug'] == 'contents/threads'
         assert sidebar_entry['label'] == 'Threads'
         assert sidebar_entry['route'] == "/#/workspaces/1/contents?type=thread"  # nopep8
         assert sidebar_entry['hexcolor'] == "#ad4cf9"
-        assert sidebar_entry['icon'] == "comments-o"
+        assert sidebar_entry['fa_icon'] == "comments-o"
 
         sidebar_entry = workspace['sidebar_entries'][6]
         assert sidebar_entry['slug'] == 'calendar'
         assert sidebar_entry['label'] == 'Calendar'
         assert sidebar_entry['route'] == "/#/workspaces/1/calendar"  # nopep8
         assert sidebar_entry['hexcolor'] == "#757575"
-        assert sidebar_entry['icon'] == "calendar-alt"
+        assert sidebar_entry['fa_icon'] == "calendar-alt"
 
     def test_api__get_workspace__err_403__unallowed_user(self) -> None:
         """

tracim/tests/library/test_content_api.py

                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
             session=self.session,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True,
+        )
         workspace_api = WorkspaceApi(
             current_user=user,
             session=self.session,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
             session=self.session,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True,
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(email='this.is@user',
-                                  groups=groups, save_now=True)
-        user_b = uapi.create_user(email='this.is@another.user',
-                                  groups=groups, save_now=True)
+        user_a = uapi.create_minimal_user(email='this.is@user',
+                                          groups=groups, save_now=True)
+        user_b = uapi.create_minimal_user(email='this.is@another.user',
+                                          groups=groups, save_now=True)
 
         wapi = WorkspaceApi(
             current_user=user_a,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(
+        user_a = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
-        user_b = uapi.create_user(
+        user_b = uapi.create_minimal_user(
             email='this.is@another.user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(
+        user_a = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
-        user_b = uapi.create_user(
+        user_b = uapi.create_minimal_user(
             email='this.is@another.user',
             groups=groups,
             save_now=True
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True,
             save_now=True
         )
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True,
             save_now=True
         )
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,

tracim/tests/library/test_group_api.py

+# coding=utf-8
+import pytest
+
+from tracim.exceptions import GroupDoesNotExist
+from tracim.lib.core.group import GroupApi
+from tracim.tests import DefaultTest
+from tracim.fixtures.users_and_groups import Base as BaseFixture
+from tracim.fixtures.content import Content as ContentFixture
+
+
+class TestGroupApi(DefaultTest):
+    fixtures = [BaseFixture, ContentFixture]
+
+    def test_unit__get_one__ok_nominal_case(self) -> None:
+        """
+        Get one group by id
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        group = api.get_one(1)
+        assert group.group_id == 1
+        assert group.group_name == 'users'
+
+    def test_unit__get_one__err__group_not_exist(self) -> None:
+        """
+        Get one group who does not exist by id
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(GroupDoesNotExist):
+            group = api.get_one(10)
+
+    def test_unit__get_one_group_with_name__nominal_case(self) -> None:
+        """
+        get one group by name
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        group = api.get_one_with_name('administrators')
+        assert group.group_id == 3
+        assert group.group_name == 'administrators'
+
+    def test_unit__get_one_with_name__err__group_not_exist(self) -> None:
+        """
+        get one group by name who does not exist
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(GroupDoesNotExist):
+            group = api.get_one_with_name('unknown_group')
+
+    def test_unit__get_all__ok__nominal_case(self):
+        """
+        get all groups
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        groups = api.get_all()
+        assert ['users', 'managers', 'administrators'] == [group.group_name for group in groups]  # nopep8

tracim/tests/library/test_notification.py

 
 
 from tracim.lib.core.notifications import DummyNotifier
-from tracim.lib.core.notifications import EmailNotifier
+
 from tracim.lib.core.notifications import NotifierFactory
+from tracim.lib.mail_notifier.notifier import EmailNotifier
 from tracim.models.auth import User
 from tracim.models.data import Content
 from tracim.tests import DefaultTest
 from tracim.tests import eq_
 
+
 class TestDummyNotifier(DefaultTest):
 
     def test_dummy_notifier__notify_content_update(self):
         c = Content()
-        notifier = DummyNotifier(self.app_config)
+        notifier = DummyNotifier(self.app_config, self.session)
         notifier.notify_content_update(c)
         # INFO - D.A. - 2014-12-09 -
         # Old notification_content_update raised an exception

tracim/tests/library/test_user_api.py

 
 class TestUserApi(DefaultTest):
 
-    def test_unit__create_and_update_user__ok__nominal_case(self):
+    def test_unit__create_minimal_user__ok__nominal_case(self):
         api = UserApi(
             current_user=None,
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bob', 'bob@bob', True)
+        u = api.create_minimal_user('bob@bob')
+        assert u.email == 'bob@bob'
+        assert u.display_name is None
 
+    def test_unit__create_minimal_user_and_update__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u = api.create_minimal_user('bob@bob')
+        api.update(u, 'bob', 'bob@bob', 'pass', do_save=True)
         nu = api.get_one_by_email('bob@bob')
-        assert nu != None
-        eq_('bob@bob', nu.email)
-        eq_('bob', nu.display_name)
+        assert nu is not None
+        assert nu.email == 'bob@bob'
+        assert nu.display_name == 'bob'
+        assert nu.validate_password('pass')
+
+    def test__unit__create__user__ok_nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=False,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
 
     def test_unit__user_with_email_exists__ok__nominal_case(self):
         api = UserApi(
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bibi', 'bibi@bibi', True)
+        u = api.create_minimal_user('bibi@bibi')
+        api.update(u, 'bibi', 'bibi@bibi', 'pass', do_save=True)
         transaction.commit()
 
         eq_(True, api.user_with_email_exists('bibi@bibi'))
         eq_(False, api.user_with_email_exists('unknown'))
 
-    def test_unit__get_one_by_email__ok__nominal_case(self):
+    def test_get_one_by_email(self):
         api = UserApi(
             current_user=None,
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bibi', 'bibi@bibi', True)
+        u = api.create_minimal_user('bibi@bibi')
+        self.session.flush()
+        api.update(u, 'bibi', 'bibi@bibi', 'pass', do_save=True)
         uid = u.user_id
         transaction.commit()
 
         with pytest.raises(UserDoesNotExist):
             api.get_one_by_email('unknown')
 
-    # def test_unit__get_all__ok__nominal_case(self):
-    #     # TODO - G.M - 29-03-2018 Check why this method is not enabled
-    #     api = UserApi(
-    #         current_user=None,
-    #         session=self.session,
-    #         config=self.config,
-    #     )
-    #     u1 = api.create_user(True)
-    #     u2 = api.create_user(True)
-    #     users = api.get_all()
-    #     assert 2==len(users)
+    def test_unit__get_all__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u1 = api.create_minimal_user('bibi@bibi')
+
+        users = api.get_all()
+        # u1 + Admin user from BaseFixture
+        assert 2 == len(users)
 
     def test_unit__get_one__ok__nominal_case(self):
         api = UserApi(
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'titi', 'titi@titi', True)
+        u = api.create_minimal_user('titi@titi')
+        api.update(u, 'titi', 'titi@titi', 'pass', do_save=True)
         one = api.get_one(u.user_id)
         eq_(u.user_id, one.user_id)
 

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):

tracim/tests/library/test_workspace.py

             current_user=admin,
             config=self.config
         )
-        u = uapi.create_user(email='u.u@u.u', save_now=True)
+        u = uapi.create_minimal_user(email='u.u@u.u', save_now=True)
         eq_([], wapi.get_notifiable_roles(workspace=w))
         rapi = RoleApi(
             session=self.session,
             current_user=None,
             config=self.app_config,
         )
-        u = uapi.create_user('u.s@e.r', [gapi.get_one(Group.TIM_USER)], True)
+        u = uapi.create_minimal_user('u.s@e.r', [gapi.get_one(Group.TIM_USER)], True)
         wapi = WorkspaceApi(
             session=self.session,
             current_user=u,

tracim/tests/models/test_controller.py

+# coding=utf-8
+import pytest
+from pyramid.config import Configurator
+
+from tracim.views.controllers import Controller
+
+
+class TestControllerModel(object):
+    """
+    Test for Controller object
+    """
+    def test_unit__bind__err__not_implemented(self):
+        controller = Controller()
+        configurator = Configurator()
+        with pytest.raises(NotImplementedError):
+            controller.bind(configurator)

tracim/tests/models/test_permission.py

+# coding=utf-8
+import transaction
+from tracim.tests import eq_
+from tracim.tests import BaseTest
+from tracim.models.auth import Permission
+
+
+class TestPermissionModel(BaseTest):
+    """
+    Test for permission model
+    """
+    def test_unit__create__ok__nominal_case(self):
+        self.session.flush()
+        transaction.commit()
+
+        name = 'my_permission'
+        description = 'my_perm_description'
+        permission = Permission()
+        permission.permission_name = name
+        permission.description = description
+
+        self.session.add(permission)
+        self.session.flush()
+        transaction.commit()
+
+        new_permission = self.session.query(Permission).filter(permission.permission_name == name).one()  # nopep8
+
+        assert new_permission.permission_name == name
+        assert new_permission.description == description
+        assert new_permission.permission_id
+        assert isinstance(new_permission.permission_id, int)
+        # TODO - G.M -24-05-2018 - Do test for groups
+
+    def test_unit__repr__ok__nominal_case(self):
+        name = 'my_permission'
+        description = 'my_perm_description'
+        permission = Permission()
+        permission.permission_name = name
+        permission.description = description
+
+        assert permission.__repr__() == "<Permission: name='my_permission'>"
+
+    def test_unit__unicode__ok__nominal_case(self):
+        name = 'my_permission'
+        description = 'my_perm_description'
+        permission = Permission()
+        permission.permission_name = name
+        permission.description = description
+
+        assert permission.__unicode__() == name
+

tracim/tests/models/test_user.py

 # -*- coding: utf-8 -*-
-import transaction
 
-from tracim.tests import eq_
+import transaction
 from tracim.tests import BaseTest
-
 from tracim.models.auth import User
 
 
 class TestUserModel(BaseTest):
-
-    def test_create(self):
+    """
+    Test for User model
+    """
+    def test_unit__create__ok__nominal_case(self):
         self.session.flush()
         transaction.commit()
         name = 'Damien'
         self.session.flush()
         transaction.commit()
 
-        new_user = self.session.query(User).filter(User.display_name==name).one()
+        new_user = self.session.query(User).filter(User.display_name == name).one()  # nopep8
+
+        assert new_user.display_name == name
+        assert new_user.email == email
+        assert new_user.email_address == email
+
+    def test_unit__password__ok__nominal_case(self):
+        """
+        Check if password can be set and hashed password
+        can be retrieve. Verify if hashed password is not
+        same as password.
+        """
+        name = 'Damien'
+        email = 'tracim@trac.im'
+        password = 'my_secure_password'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+        assert user._password is None
+        user.password = password
+        assert user._password is not None
+        assert user._password != password
+        assert user.password == user._password
+
+    def test__unit__validate_password__ok__nominal_case(self):
+        """
+        Check if validate_password can correctly check if password i the correct
+        one
+        """
 
-        eq_(new_user.display_name, name)
-        eq_(new_user.email, email)
-        eq_(new_user.email_address, email)
+        name = 'Damien'
+        email = 'tracim@trac.im'
+        password = 'my_secure_password'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+        user.password = password
+
+        assert user.validate_password(password) is True
 
-    def test_null_password(self):
+    def test_unit__validate_password__false__null_password(self):
         # Check bug #70 fixed
         # http://tracim.org/workspaces/4/folders/5/threads/70
 
         user.display_name = name
         user.email = email
 
-        eq_(False, user.validate_password(None))
+        assert user.validate_password('') is False
+
+    def test_unit__validate_password__false__bad_password(self):
+        """
+        Check if validate_password can correctly check if password is
+        an uncorrect correct one
+        """
+        name = 'Damien'
+        email = 'tracim@trac.im'
+        password = 'my_secure_password'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+        user.password = password
+
+        assert user.validate_password('uncorrect_password') is False
+
+    def test_unit__repr__ok__nominal_case(self):
+        name = 'Damien'
+        email = 'tracim@trac.im'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+
+        assert user.__repr__() == "<User: email='tracim@trac.im', display='Damien'>"  # nopep8
+
+    def test_unit__unicode__ok__nominal_case(self):
+        name = 'Damien'
+        email = 'tracim@trac.im'
+
+        user = User()
+        user.display_name = name
+        user.email = email
+
+        assert user.__unicode__() == name
+
+    def test__unit__unicode__ok__no_display_name(self):
+
+        email = 'tracim@trac.im'
+
+        user = User()
+        user.email = email
+
+        assert user.__unicode__() == email

tracim/views/core_api/schemas.py

                     'which must be replaced on backend size '
                     '(the route must be ready-to-use)'
     )
-    icon = marshmallow.fields.String(
+    fa_icon = marshmallow.fields.String(
         example='file-text-o',
         description='CSS class of the icon. Example: file-o for using Fontawesome file-text-o icon',  # nopep8
     )
 class ApplicationSchema(marshmallow.Schema):
     label = marshmallow.fields.String(example='Calendar')
     slug = marshmallow.fields.String(example='calendar')
-    icon = marshmallow.fields.String(
+    fa_icon = marshmallow.fields.String(
         example='file-o',
         description='CSS class of the icon. Example: file-o for using Fontawesome file-o icon',  # nopep8
     )
         validate=OneOf([status.value for status in GlobalStatus]),
     )
     label = marshmallow.fields.String(example='Open')
-    icon = marshmallow.fields.String(example='fa-check')
+    fa_icon = marshmallow.fields.String(example='fa-check')
     hexcolor = marshmallow.fields.String(example='#0000FF')
 
 
         example='pagehtml',
         validate=OneOf([content.slug for content in CONTENT_DEFAULT_TYPE]),
     )
-    icon = marshmallow.fields.String(
+    fa_icon = marshmallow.fields.String(
         example='fa-file-text-o',
         description='CSS class of the icon. Example: file-o for using Fontawesome file-o icon',  # nopep8
     )

tracim/views/core_api/session_controller.py

 from tracim.views.core_api.schemas import NoContentSchema
 from tracim.views.core_api.schemas import LoginOutputHeaders
 from tracim.views.core_api.schemas import BasicAuthSchema
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import AuthenticationFailed
 
 
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.output_body(UserSchema(),)
     def whoami(self, context, request: TracimRequest, hapic_data=None):
         """

tracim/views/core_api/system_controller.py

 # coding=utf-8
 from pyramid.config import Configurator
 
-from tracim.exceptions import NotAuthentificated, InsufficientUserProfile
+from tracim.exceptions import NotAuthenticated, InsufficientUserProfile
 from tracim.lib.utils.authorization import require_profile
 from tracim.models import Group
 from tracim.models.applications import applications
 class SystemController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @require_profile(Group.TIM_USER)
     @hapic.output_body(ApplicationSchema(many=True),)
         return applications
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @require_profile(Group.TIM_USER)
     @hapic.output_body(ContentTypeSchema(many=True),)

tracim/views/core_api/user_controller.py

 
 from tracim import hapic, TracimRequest
 
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import InsufficientUserProfile
 from tracim.exceptions import UserDoesNotExist
 from tracim.lib.core.workspace import WorkspaceApi
 class UserController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(UserDoesNotExist, HTTPStatus.NOT_FOUND)
     @require_same_user_or_profile(Group.TIM_ADMIN)

tracim/views/core_api/workspace_controller.py

 from tracim.models.data import UserRoleInWorkspace, ActionDescription
 from tracim.models.context_models import UserRoleWorkspaceInContext
 from tracim.models.context_models import ContentInContext
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import InsufficientUserProfile
 from tracim.exceptions import WorkspaceNotFound
 from tracim.views.controllers import Controller
 from tracim.views.core_api.schemas import WorkspaceSchema
 from tracim.views.core_api.schemas import WorkspaceIdPathSchema
 from tracim.views.core_api.schemas import WorkspaceMemberSchema
-from tracim.models.data import ContentType
+from tracim.models.contents import ContentTypeLegacy as ContentType
 from tracim.models.revision_protection import new_revision
 
 
 class WorkspaceController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)
         return wapi.get_workspace_with_context(request.current_workspace)
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)
         ]
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)
         return contents
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
         return content
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.CONTRIBUTOR)

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)