Merge pull request #545 from inkhey/webdav_move_and_rename_fix

doc/apache.md

     
     root_path = ''
     
+    # Tracim doesn't support digest auth for webdav
+    acceptbasic = True
+    acceptdigest = False
+    defaultdigest = False
     #===============================================================================
     # Lock Manager
     #

doc/webdav.md

+# How to use webdav from different OS ?
+
+## Windows
+
+### Windows 7
+
+- Open Start Menu.
+- Click on Computer.
+- click on "Map network drive".
+
+### Windows 8 and 10
+
+- Open File explorer.
+- Right click on "This PC" (left panel)
+- From the dropdown menu, select "Map network drive".
+
+### Map Network drive Windows:
+
+Webdav Windows addresses are similar to:
+
+```
+https://<yourinstance>/webdav/ (secure)
+http://<yourinstance>/webdav/ (unsecure)
+```
+
+- Enter the address of webdav (you can find it in each workspace, under workspace details)
+- Check "Reconnect at sign-in" and "Connect using different credentials".
+- Click "Finish".
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.
+
+### Unsecure HTTP using Windows
+
+If you want to use webdav with tracim without https, you need to set Windows to accept basic auth in http.
+
+To enable it:
+- Launch regedit.
+- Go to "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters\BasicAuthLevel".
+- set "BasicAuthLevel" to "2".
+
+## OSX
+
+Webdav OSX addresses are similar to:
+
+```
+https://<yourinstance>/webdav/ (secure)
+http://<yourinstance>/webdav/ (unsecure)
+```
+
+- In the Finder, choose "Go > Connect to Server".
+- Enter the address of webdav (you can find it in each workspace, under workspace details). Click Connect.
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.
+
+## Linux
+
+Webdav Linux addresses are similar to:
+
+```
+davs://<yourinstance>/webdav/ (secure)
+dav://<yourinstance>/webdav/ (unsecure)
+```
+
+### Gnome3 (nautilus)
+
+- Launch nautilus.
+- Show url bar : Ctrl+l.
+- Enter the address of webdav (you can find it in each workspace, under workspace details). Press Enter.
+- Your login/password will be ask. Use your Tracim credentials.
+- After that, your webdav access should be mounted.

tracim/migration/versions/2b4043fa2502_remove_webdav_right_digest_response_.py

+"""remove webdav_right_digest_response_hash from database
+
+Revision ID: 2b4043fa2502
+Revises: f3852e1349c4
+Create Date: 2018-03-13 14:41:38.590375
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '2b4043fa2502'
+down_revision = 'f3852e1349c4'
+
+from alembic import op
+from sqlalchemy import Column, Unicode
+
+
+def upgrade():
+    with op.batch_alter_table('users') as batch_op:
+        batch_op.drop_column('webdav_left_digest_response_hash')
+
+
+def downgrade():
+    with op.batch_alter_table('users') as batch_op:
+        batch_op.add_column(
+            Column('webdav_left_digest_response_hash', Unicode(128))
+        )

tracim/tracim/lib/content.py

 from tracim.lib import cmp_to_key
 from tracim.lib.notifications import NotifierFactory
 from tracim.lib.utils import SameValueError
+from tracim.lib.utils import current_date_for_filename
 from tracim.model import DBSession
 from tracim.model import new_revision
 from tracim.model.auth import User
     def archive(self, content: Content):
         content.owner = self._user
         content.is_archived = True
+        # TODO - G.M - 12-03-2018 - Inspect possible label conflict problem
+        # INFO - G.M - 12-03-2018 - Set label name to avoid trouble when
+        # un-archiving file.
+        content.label = '{label}-{action}-{date}'.format(
+            label=content.label,
+            action='archived',
+            date=current_date_for_filename()
+        )
         content.revision_type = ActionDescription.ARCHIVING
 
     def unarchive(self, content: Content):
     def delete(self, content: Content):
         content.owner = self._user
         content.is_deleted = True
+        # TODO - G.M - 12-03-2018 - Inspect possible label conflict problem
+        # INFO - G.M - 12-03-2018 - Set label name to avoid trouble when
+        # un-deleting file.
+        content.label = '{label}-{action}-{date}'.format(
+            label=content.label,
+            action='deleted',
+            date=current_date_for_filename()
+        )
         content.revision_type = ActionDescription.DELETION
 
     def undelete(self, content: Content):

tracim/tracim/lib/daemons.py

             print(
                 "WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/.")
         from wsgidav.dir_browser import WsgiDavDirBrowser
-        from tracim.lib.webdav.tracim_http_authenticator import TracimHTTPAuthenticator
+        from wsgidav.http_authenticator import HTTPAuthenticator
         from wsgidav.error_printer import ErrorPrinter
         from tracim.lib.webdav.utils import TracimWsgiDavDebugFilter
 
         config['middleware_stack'] = [
             TracimEnforceHTTPS,
             WsgiDavDirBrowser,
-            TracimHTTPAuthenticator,
+            HTTPAuthenticator,
             ErrorPrinter,
             TracimWsgiDavDebugFilter,
         ]

tracim/tracim/lib/utils.py

 # -*- coding: utf-8 -*-
+import datetime
 import os
 import time
 import signal
         db=cfg.EMAIL_SENDER_REDIS_DB,
     ))
 
+def current_date_for_filename() -> str:
+    """
+    ISO8601 current date, adapted to be used in filename (for
+    webdav feature for example), with trouble-free characters.
+    :return: current date as string like "2018-03-19T15.49.27.246592"
+    """
+    # INFO - G.M - 19-03-2018 - As ':' is in transform_to_bdd method in
+    # webdav utils, it may cause trouble. So, it should be replaced to
+    # a character which will not change in bdd.
+    return datetime.datetime.now().isoformat().replace(':', '.')
 
 class TracimEnforceHTTPS(BaseMiddleware):
 

tracim/tracim/lib/webdav/design.py

     return aff
 
 def designPage(content: data.Content, content_revision: data.ContentRevisionRO) -> str:
-    hist = content.get_history()
+    hist = content.get_history(drop_empty_revision=False)
     histHTML = '<table class="table table-striped table-hover">'
     for event in hist:
         if isinstance(event, VirtualEvent):
     return page
 
 def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
-        hist = content.get_history()
+        hist = content.get_history(drop_empty_revision=False)
 
         allT = []
         allT += comments

tracim/tracim/lib/webdav/sql_domain_controller.py

 
 from tracim.lib.user import UserApi
 
+class DigestAuthNotImplemented(Exception):
+    pass
+
 class TracimDomainController(object):
     """
     The domain controller is used by http_authenticator to authenticate the user every time a request is
     def getDomainRealm(self, inputURL, environ):
         return '/'
 
+    def getRealmUserPassword(self, realmname, username, environ):
+        """
+        This method is normally only use for digest auth. wsgidav need
+        plain password to deal with it. as we didn't
+        provide support for this kind of auth, this method raise an exception.
+        """
+        raise DigestAuthNotImplemented
+
     def requireAuthentication(self, realmname, environ):
         return True
 
         except:
             return False
 
-    def get_left_digest_response_hash(self, realmname, username, environ):
-        """
-        Called by our http_authenticator to get the hashed md5 digest for the current user that is also sent by
-        the webdav client
-        """
-        try:
-            user = self._api.get_one_by_email(username)
-            return user.webdav_left_digest_response_hash
-        except:
-            return None
-
     def authDomainUser(self, realmname, username, password, environ):
         """
         If you ever feel the need to send a request al-mano with a curl, this is the function that'll be called by

tracim/tracim/lib/webdav/sql_resources.py

 
 class ManageActions(object):
     """
-    This object is used to encapsulate all Deletion/Archiving related method as to not duplicate too much code
+    This object is used to encapsulate all Deletion/Archiving related
+    method as to not duplicate too much code
     """
     def __init__(self, action_type: str, api: ContentApi, content: Content):
         self.content_api = api
             ActionDescription.UNDELETION: self.content_api.undelete
         }
 
-        self._to_name = {
-            ActionDescription.ARCHIVING: 'archived',
-            ActionDescription.DELETION: 'deleted'
-        }
-
         self._type = action_type
-        self._new_name = self.make_name()
 
     def action(self):
-        try:
-            # When undeleting/unarchiving we except a content with the new name to not exist, thus if we
-            # don't get an error and the database request send back a result, we stop the action
-            self.content_api.get_one_by_label_and_parent(self._new_name, self.content.parent)
-            raise DAVError(HTTP_FORBIDDEN)
-        except NoResultFound:
-            with new_revision(self.content):
-                self.content_api.update_content(self.content, self._new_name)
-                self._actions[self._type](self.content)
-                self.content_api.save(self.content, self._type)
-
-            transaction.commit()
-
-    def make_name(self) -> str:
-        """
-        Will create the new name, either by adding '- deleted the [date]' after the name when archiving/deleting or
-        removing this string when undeleting/unarchiving
-        """
-        new_name = self.content.get_label_as_file()
-        extension = ''
-
-        # if the content has no label, the last .ext is important
-        # thus we want to rename a file from 'file.txt' to 'file - deleted... .txt' and not 'file.txt - deleted...'
-        is_file_name = self.content.label == ''
-        if is_file_name:
-            search = re.search(r'(\.[^.]+)$', new_name)
-            if search:
-                extension = search.group(0)
-            new_name = re.sub(r'(\.[^.]+)$', '', new_name)
-
-        if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]:
-            new_name += ' - %s the %s' % (self._to_name[self._type], datetime.now().strftime('%d-%m-%Y at %H:%M'))
-        else:
-            new_name = re.sub(
-                r'( - (%s|%s) the .*)$' % (self._to_name[ActionDescription.DELETION], self._to_name[ActionDescription.ARCHIVING]),
-                '',
-                new_name
-            )
-
-        new_name += extension
+        with new_revision(self.content):
+            self._actions[self._type](self.content)
+            self.content_api.save(self.content, self._type)
 
-        return new_name
+        transaction.commit()
 
 
 class Root(DAVCollection):
         if invalid_path:
             raise DAVError(HTTP_FORBIDDEN)
 
-    def move_file(self, destpath):
+    def move_file(self, destpath: str) -> None:
+        """
+        Move file mean changing the path to access to a file. This can mean
+        simple renaming(1), moving file from a directory to one another(2)
+        but also renaming + moving file from a directory to one another at
+        the same time (3).
+
+        (1): move /dir1/file1 -> /dir1/file2
+        (2): move /dir1/file1 -> /dir2/file1
+        (3): move /dir1/file1 -> /dir2/file2
+        :param destpath: destination path of webdav move
+        :return: nothing
+        """
 
         workspace = self.content.workspace
         parent = self.content.parent
 
         with new_revision(self.content):
+            # INFO - G.M - 2018-03-09 - First, renaming file if needed
             if basename(destpath) != self.getDisplayName():
                 new_given_file_name = transform_to_bdd(basename(destpath))
                 new_file_name, new_file_extension = \
                 )
                 self.content.file_extension = new_file_extension
                 self.content_api.save(self.content)
-            else:
-                workspace_api = WorkspaceApi(self.user)
-                content_api = ContentApi(self.user)
 
-                destination_workspace = self.provider.get_workspace_from_path(
-                    destpath,
-                    workspace_api,
-                )
-
-                destination_parent = self.provider.get_parent_from_path(
-                    destpath,
-                    content_api,
-                    destination_workspace,
-                )
+            # INFO - G.M - 2018-03-09 - Moving file if needed
+            workspace_api = WorkspaceApi(self.user)
+            content_api = ContentApi(self.user)
 
+            destination_workspace = self.provider.get_workspace_from_path(
+                destpath,
+                workspace_api,
+            )
+            destination_parent = self.provider.get_parent_from_path(
+                destpath,
+                content_api,
+                destination_workspace,
+            )
+            if destination_parent != parent or destination_workspace != workspace:  # nopep8
+                #  INFO - G.M - 12-03-2018 - Avoid moving the file "at the same place"  # nopep8
+                #  if the request does not result in a real move.
                 self.content_api.move(
                     item=self.content,
                     new_parent=destination_parent,

tracim/tracim/lib/webdav/tracim_http_authenticator.py

-import os
-import re
-
-from wsgidav.http_authenticator import HTTPAuthenticator
-from wsgidav import util
-import cherrypy
-
-from tracim.lib.user import CurrentUserGetterApi
-from tracim.lib.user import CURRENT_USER_WSGIDAV
-
-_logger = util.getModuleLogger(__name__, True)
-HOTFIX_WINXP_AcceptRootShareLogin = True
-
-
-class TracimHTTPAuthenticator(HTTPAuthenticator):
-    def __init__(self, application, config):
-        super(TracimHTTPAuthenticator, self).__init__(application, config)
-        self._headerfixparser = re.compile(r'([\w]+)=("[^"]*,[^"]*"),')
-
-    def authDigestAuthRequest(self, environ, start_response):
-        realmname = self._domaincontroller.getDomainRealm(environ["PATH_INFO"], environ)
-
-        isinvalidreq = False
-
-        authheaderdict = dict([])
-        authheaders = environ["HTTP_AUTHORIZATION"] + ","
-        if not authheaders.lower().strip().startswith("digest"):
-            isinvalidreq = True
-            # Hotfix for Windows file manager and OSX Finder:
-        # Some clients don't urlencode paths in auth header, so uri value may
-        # contain commas, which break the usual regex headerparser. Example:
-        # Digest username="user",realm="/",uri="a,b.txt",nc=00000001, ...
-        # -> [..., ('uri', '"a'), ('nc', '00000001'), ...]
-        # Override any such values with carefully extracted ones.
-        authheaderlist = self._headerparser.findall(authheaders)
-        authheaderfixlist = self._headerfixparser.findall(authheaders)
-        if authheaderfixlist:
-            _logger.info("Fixing authheader comma-parsing: extend %s with %s" \
-                         % (authheaderlist, authheaderfixlist))
-            authheaderlist += authheaderfixlist
-        for authheader in authheaderlist:
-            authheaderkey = authheader[0]
-            authheadervalue = authheader[1].strip().strip("\"")
-            authheaderdict[authheaderkey] = authheadervalue
-
-        _logger.debug("authDigestAuthRequest: %s" % environ["HTTP_AUTHORIZATION"])
-        _logger.debug("  -> %s" % authheaderdict)
-
-        if "username" in authheaderdict:
-            req_username = authheaderdict["username"]
-            req_username_org = req_username
-            # Hotfix for Windows XP:
-            #   net use W: http://127.0.0.1/dav /USER:DOMAIN\tester tester
-            # will send the name with double backslashes ('DOMAIN\\tester')
-            # but send the digest for the simple name ('DOMAIN\tester').
-            if r"\\" in req_username:
-                req_username = req_username.replace("\\\\", "\\")
-                _logger.info("Fixing Windows name with double backslash: '%s' --> '%s'" % (req_username_org, req_username))
-
-            if not self._domaincontroller.isRealmUser(realmname, req_username, environ):
-                isinvalidreq = True
-        else:
-            isinvalidreq = True
-
-            # TODO: Chun added this comments, but code was commented out
-            # Do not do realm checking - a hotfix for WinXP using some other realm's
-            # auth details for this realm - if user/password match
-
-        if 'realm' in authheaderdict:
-            if authheaderdict["realm"].upper() != realmname.upper():
-                if HOTFIX_WINXP_AcceptRootShareLogin:
-                    # Hotfix: also accept '/'
-                    if authheaderdict["realm"].upper() != "/":
-                        isinvalidreq = True
-                else:
-                    isinvalidreq = True
-
-        if "algorithm" in authheaderdict:
-            if authheaderdict["algorithm"].upper() != "MD5":
-                isinvalidreq = True  # only MD5 supported
-
-        if "uri" in authheaderdict:
-            req_uri = authheaderdict["uri"]
-
-        if "nonce" in authheaderdict:
-            req_nonce = authheaderdict["nonce"]
-        else:
-            isinvalidreq = True
-
-        req_hasqop = False
-        if "qop" in authheaderdict:
-            req_hasqop = True
-            req_qop = authheaderdict["qop"]
-            if req_qop.lower() != "auth":
-                isinvalidreq = True  # only auth supported, auth-int not supported
-        else:
-            req_qop = None
-
-        if "cnonce" in authheaderdict:
-            req_cnonce = authheaderdict["cnonce"]
-        else:
-            req_cnonce = None
-            if req_hasqop:
-                isinvalidreq = True
-
-        if "nc" in authheaderdict:  # is read but nonce-count checking not implemented
-            req_nc = authheaderdict["nc"]
-        else:
-            req_nc = None
-            if req_hasqop:
-                isinvalidreq = True
-
-        if "response" in authheaderdict:
-            req_response = authheaderdict["response"]
-        else:
-            isinvalidreq = True
-
-        if not isinvalidreq:
-            left_digest_response_hash = self._domaincontroller.get_left_digest_response_hash(realmname, req_username, environ)
-
-            req_method = environ["REQUEST_METHOD"]
-
-            required_digest = self.tracim_compute_digest_response(left_digest_response_hash, req_method, req_uri, req_nonce,
-                                                         req_cnonce, req_qop, req_nc)
-
-            if required_digest != req_response:
-                _logger.warning("computeDigestResponse('%s', '%s', ...): %s != %s" % (
-                realmname, req_username, required_digest, req_response))
-                isinvalidreq = True
-            else:
-                _logger.debug("digest succeeded for realm '%s', user '%s'" % (realmname, req_username))
-            pass
-
-        if isinvalidreq:
-            _logger.warning("Authentication failed for user '%s', realm '%s'" % (req_username, realmname))
-            return self.sendDigestAuthResponse(environ, start_response)
-
-        environ["http_authenticator.realm"] = realmname
-        environ["http_authenticator.username"] = req_username
-
-        # Set request current user email to be able to recognise him later
-        cherrypy.request.current_user_email = req_username
-        CurrentUserGetterApi.set_thread_local_getter(CURRENT_USER_WSGIDAV)
-
-        return self._application(environ, start_response)
-
-    def tracim_compute_digest_response(self, left_digest_response_hash, method, uri, nonce, cnonce, qop, nc):
-        # A1 : username:realm:password
-        A2 = method + ":" + uri
-        if qop:
-            digestresp = self.md5kd(left_digest_response_hash, nonce + ":" + nc + ":" + cnonce + ":" + qop + ":" + self.md5h(A2))
-        else:
-            digestresp = self.md5kd(left_digest_response_hash, nonce + ":" + self.md5h(A2))
-            # print(A1, A2)
-        # print(digestresp)
-        return digestresp

tracim/tracim/model/auth.py

     is_active = Column(Boolean, default=True, nullable=False)
     imported_from = Column(Unicode(32), nullable=True)
     timezone = Column(Unicode(255), nullable=False, server_default='')
-    _webdav_left_digest_response_hash = Column('webdav_left_digest_response_hash', Unicode(128))
     auth_token = Column(Unicode(255))
     auth_token_created = Column(DateTime)
 
 
         Hash cleartext password on the fly,
         Store its ciphertext version,
-        Update the WebDAV hash as well.
         """
         self._password = self._hash_password(cleartext_password)
-        self.update_webdav_digest_auth(cleartext_password)
 
     def _get_password(self) -> str:
         """Return the hashed version of the password."""
     password = synonym('_password', descriptor=property(_get_password,
                                                         _set_password))
 
-    @classmethod
-    def _hash_digest(cls, digest):
-        return md5(bytes(digest, 'utf-8')).hexdigest()
-
-    def _set_hash_digest(self, digest):
-        self._webdav_left_digest_response_hash = self._hash_digest(digest)
-
-    def _get_hash_digest(self):
-        return self._webdav_left_digest_response_hash
-
-    webdav_left_digest_response_hash = synonym('_webdav_left_digest_response_hash',
-                                               descriptor=property(_get_hash_digest,
-                                                                   _set_hash_digest))
-
-    def update_webdav_digest_auth(self, cleartext_password: str) -> None:
-        self.webdav_left_digest_response_hash \
-            = '{username}:/:{cleartext_password}'.format(
-                username=self.email,
-                cleartext_password=cleartext_password,
-            )
 
     def validate_password(self, cleartext_password: str) -> bool:
         """
             hash = sha256()
             hash.update((cleartext_password + self.password[:64]).encode('utf-8'))
             result = self.password[64:] == hash.hexdigest()
-            if result and not self.webdav_left_digest_response_hash:
-                self.update_webdav_digest_auth(cleartext_password)
         return result
 
     def get_display_name(self, remove_email_part: bool=False) -> str:

tracim/tracim/model/data.py

 
         return ContentType.sorted(types)
 
-    def get_history(self) -> '[VirtualEvent]':
+    def get_history(self, drop_empty_revision=False) -> '[VirtualEvent]':
         events = []
         for comment in self.get_comments():
             events.append(VirtualEvent.create_from_content(comment))
-        for revision in self.revisions:
+
+        revisions = sorted(self.revisions, key=lambda rev: rev.revision_id)
+        for revision in revisions:
+            # INFO - G.M - 09-03-2018 - Do not show file revision with empty
+            # file to have a more clear view of revision.
+            # Some webdav client create empty file before uploading, we must
+            # have possibility to not show the related revision
+            if drop_empty_revision:
+                if revision.depot_file and revision.depot_file.file.content_length == 0:  # nopep8
+                    # INFO - G.M - 12-03-2018 -Always show the last and
+                    # first revision.
+                    if revision != revisions[-1] and revision != revisions[0]:
+                        continue
+
             events.append(VirtualEvent.create_from_content_revision(revision))
 
         sorted_events = sorted(events,

tracim/tracim/model/serializers.py

             links=[],
             revision_nb = len(content.revisions),
             selected_revision='latest' if content.revision_to_serialize<=0 else content.revision_to_serialize,
-            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history()),
+            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history(drop_empty_revision=True)),  # nopep8
             is_editable=content.is_editable,
             is_deleted=content.is_deleted,
             is_archived=content.is_archived,
             workspace = context.toDict(item.workspace),
             comments = reversed(context.toDict(item.get_comments())),
             is_new=item.has_new_information_for(context.get_user()),
-            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history()),
+            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history(drop_empty_revision=True)),  # nopep8
             is_editable=item.is_editable,
             is_deleted=item.is_deleted,
             is_archived=item.is_archived,

tracim/tracim/tests/command/user.py

         # Check webdav digest exist for this user
         user = DBSession.query(User)\
             .filter(User.email == 'new-user@algoo.fr').one()
-        ok_(user.webdav_left_digest_response_hash)
 
     def test_update_password(self):
         self._create_user('new-user@algoo.fr', 'toor')
         # Grab webdav digest
         user = DBSession.query(User) \
             .filter(User.email == 'new-user@algoo.fr').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         self._execute_command(
             UpdateUserCommand,
         # Grab new webdav digest to compare it
         user = DBSession.query(User) \
             .filter(User.email == 'new-user@algoo.fr').one()
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be different',
-        )
 
     def test_create_with_group(self):
         more_args = ['--add-to-group', 'managers', '--add-to-group', 'administrators']

tracim/tracim/tests/functional/test_admin.py

         ok_(user, msg="User should exist now")
         ok_(user.validate_password('password'))
 
-        # User must have webdav digest
-        ok_(user.webdav_left_digest_response_hash)
-
     def test_update_user_password(self):
         self._connect_user(
             'admin@admin.admin',
 
         user = DBSession.query(User) \
             .filter(User.email == 'an-other-email@test.local').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         self.app.post(
             '/admin/users/{user_id}/password?_method=PUT'.format(
         user = DBSession.query(User) \
             .filter(User.email == 'an-other-email@test.local').one()
         ok_(user.validate_password('new-password'))
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be updated',
-        )

tracim/tracim/tests/functional/test_user.py

 
         user = DBSession.query(User) \
             .filter(User.email == 'lawrence-not-real-email@fsf.local').one()
-        webdav_digest = user.webdav_left_digest_response_hash
 
         try_post_user = self.app.post(
             '/user/{user_id}/password?_method=PUT'.format(
         user = DBSession.query(User) \
             .filter(User.email == 'lawrence-not-real-email@fsf.local').one()
         ok_(user.validate_password('new-password'))
-        ok_(
-            webdav_digest != user.webdav_left_digest_response_hash,
-            msg='Webdav digest should be updated',
-        )

tracim/tracim/tests/library/test_webdav.py

             )
         )
 
+    def test_unit__move_and_rename_content__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            environ,
+        )
+
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'w1f1d1') \
+            .one()  # It must exist only one revision, cf fixtures
+        ok_(content_w1f1d1, msg='w1f1d1 should be exist')
+        content_w1f1d1_id = content_w1f1d1.content_id
+        content_w1f1d1_parent = content_w1f1d1.parent
+        eq_(
+            content_w1f1d1_parent.label,
+            'w1f1',
+            msg='field parent should be w1f1',
+        )
+
+        w1f1d1.moveRecursive('/w1/w1f2/w1f1d1_RENAMED.txt')
+
+        # Database content is moved
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id == content_w1f1d1_id) \
+            .order_by(ContentRevisionRO.revision_id.desc()) \
+            .first()
+        ok_(
+            content_w1f1d1.parent.label != content_w1f1d1_parent.label,
+            msg='file should be moved in w1f2 but is in {0}'.format(
+                content_w1f1d1.parent.label
+            )
+        )
+        eq_(
+            'w1f1d1_RENAMED',
+            content_w1f1d1.label,
+            msg='File should be labeled w1f1d1_RENAMED, not {0}'.format(
+                content_w1f1d1.label
+            )
+        )
+
     def test_unit__move_content__ok__another_workspace(self):
         provider = self._get_provider()
         environ = self._get_environ(

tracim/wsgidav.conf.sample

 
 root_path = ''
 
+# Tracim doesn't support digest auth for webdav
+acceptbasic = True
+acceptdigest = False
+defaultdigest = False
 #===============================================================================
 # Lock Manager
 #