Introduce path unicity check

tracim/migration/versions/c1cea4bbae16_file_extentions_value_for_pages_and_.py

+"""file_extentions value for Pages and Threads
+
+Revision ID: c1cea4bbae16
+Revises: 59fc98c3c965
+Create Date: 2016-11-30 10:41:51.893531
+
+"""
+
+# revision identifiers, used by Alembic.
+
+revision = 'c1cea4bbae16'
+down_revision = '59fc98c3c965'
+
+from alembic import op
+import sqlalchemy as sa
+
+content_revision_helper = sa.Table(
+    'content_revisions',
+    sa.MetaData(),
+    sa.Column('revision_id', sa.Integer, primary_key=True),
+    sa.Column('content_id', sa.ForeignKey(u'content.id'), nullable=False),
+    sa.Column('owner_id', sa.ForeignKey(u'users.user_id'), index=True),
+    sa.Column('label', sa.String(1024), nullable=False),
+    sa.Column('description', sa.Text, nullable=False),
+    sa.Column('file_extension', sa.String(255), nullable=False),
+    sa.Column('file_mimetype', sa.String(255), nullable=False),
+    sa.Column('file_content', sa.LargeBinary),
+    sa.Column('properties', sa.Text, nullable=False),
+    sa.Column('type', sa.String(32), nullable=False),
+    sa.Column('status', sa.String(32), nullable=False),
+    sa.Column('created', sa.DateTime, nullable=False),
+    sa.Column('updated', sa.DateTime, nullable=False),
+    sa.Column('is_deleted', sa.Boolean, nullable=False),
+    sa.Column('is_archived', sa.Boolean, nullable=False),
+    sa.Column('is_temporary', sa.Boolean, nullable=False),
+    sa.Column('revision_type', sa.String(32), nullable=False),
+    sa.Column('workspace_id', sa.ForeignKey(u'workspaces.workspace_id')),
+    sa.Column('parent_id', sa.ForeignKey(u'content.id'), index=True),
+)
+
+
+def upgrade():
+    connection = op.get_bind()
+
+    for content_revision in connection.execute(
+            content_revision_helper.select()
+    ):
+        if content_revision.type in ('page', 'thread'):
+            # Update record
+            connection.execute(
+                content_revision_helper.update()
+                    .where(
+                        content_revision_helper.c.revision_id ==
+                        content_revision.revision_id
+                    ).values(
+                        file_extension='.html',
+                    )
+                )
+
+
+def downgrade():
+    connection = op.get_bind()
+
+    for content_revision in connection.execute(
+            content_revision_helper.select()
+    ):
+        # On work with FILE
+        if content_revision.type in ('page', 'thread'):
+            # Update record
+            connection.execute(
+                content_revision_helper.update()
+                    .where(
+                        content_revision_helper.c.revision_id ==
+                        content_revision.revision_id
+                    ).values(
+                        file_extension='',
+                    )
+                )

tracim/tracim/controllers/__init__.py

 """Controllers for the tracim application."""
 from sqlalchemy.orm.exc import NoResultFound
 from tg import abort
+from tracim.lib.integrity import PathValidationManager
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
 from tracim.lib.workspace import WorkspaceApi
 
 import tg
     TEMPLATE_NEW = 'unknown "template new"'
     TEMPLATE_EDIT = 'unknown "template edit"'
 
+    def __init__(self):
+        super().__init__()
+        self._path_validation = PathValidationManager(
+            is_case_sensitive=False,
+        )
+
     def _before(self, *args, **kw):
         """
         Instantiate the current workspace in tg.tmpl_context
             item = api.get_one(int(item_id), self._item_type, workspace)
             with new_revision(item):
                 api.update_content(item, label, content)
+
+                if not self._path_validation.validate_new_content(item):
+                    return render_invalid_integrity_chosen_path(
+                        item.get_label(),
+                    )
+
                 api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)

tracim/tracim/controllers/admin/workspace.py

 from tracim.lib import CST
 from tracim.lib.base import BaseController
 from tracim.lib.helpers import on_off_to_boolean
+from tracim.lib.integrity import PathValidationManager
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
 from tracim.lib.user import UserApi
 from tracim.lib.userworkspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
      responsible / advanced contributor. / contributor / reader
     """
 
+    def __init__(self):
+        super().__init__()
+        self._path_validation = PathValidationManager(
+            is_case_sensitive=False,
+        )
+
     @property
     def _base_url(self):
         return '/admin/workspaces'
         workspace_api_controller = WorkspaceApi(user)
         calendar_enabled = on_off_to_boolean(calendar_enabled)
 
+        # Display error page to user if chosen label is in conflict
+        if not self._path_validation.workspace_label_is_free(name):
+            return render_invalid_integrity_chosen_path(name)
+
         workspace = workspace_api_controller.create_workspace(
             name,
             description,
         user = tmpl_context.current_user
         workspace_api_controller = WorkspaceApi(user)
         calendar_enabled = on_off_to_boolean(calendar_enabled)
-
         workspace = workspace_api_controller.get_one(id)
+
+        # Display error page to user if chosen label is in conflict
+        if name != workspace.label and \
+                not self._path_validation.workspace_label_is_free(name):
+            return render_invalid_integrity_chosen_path(name)
+
         workspace.label = name
         workspace.description = description
         workspace.calendar_enabled = calendar_enabled

tracim/tracim/controllers/content.py

 # -*- coding: utf-8 -*-
-import sys
-
 __author__ = 'damien'
 
-from cgi import FieldStorage
+import sys
+import traceback
 
+from cgi import FieldStorage
 import tg
 from tg import tmpl_context
 from tg.i18n import ugettext as _
 from tg.predicates import not_anonymous
 
-import traceback
-
 from tracim.controllers import TIMRestController
 from tracim.controllers import TIMRestPathContextSetup
 from tracim.controllers import TIMRestControllerWithBreadcrumb
 from tracim.controllers import TIMWorkspaceContentRestController
-
 from tracim.lib import CST
 from tracim.lib.base import BaseController
 from tracim.lib.base import logger
 from tracim.lib.predicates import current_user_is_contributor
 from tracim.lib.predicates import current_user_is_content_manager
 from tracim.lib.predicates import require_current_user_is_owner
-
 from tracim.model.serializers import Context, CTX, DictLikeClass
 from tracim.model.data import ActionDescription
 from tracim.model import new_revision
+from tracim.model import DBSession
 from tracim.model.data import Content
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
+
 
 class UserWorkspaceFolderThreadCommentRestController(TIMRestController):
 
     def post(self, label='', file_data=None):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
+        folder = tmpl_context.folder
 
         api = ContentApi(tmpl_context.current_user)
-
-        file = api.create(ContentType.File, workspace, tmpl_context.folder, label)
-        api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
+        with DBSession.no_autoflush:
+            file = api.create(ContentType.File, workspace, folder, label)
+            api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
+
+            # Display error page to user if chosen label is in conflict
+            if not self._path_validation.validate_new_content(file):
+                return render_invalid_integrity_chosen_path(
+                    file.get_label_as_file(),
+                )
         api.save(file, ActionDescription.CREATION)
 
         tg.flash(_('File created'), CST.STATUS_OK)
                         item, label if label else item.label,
                         comment if comment else ''
                     )
+
+                    # Display error page to user if chosen label is in conflict
+                    if not self._path_validation.validate_new_content(
+                        updated_item,
+                    ):
+                        return render_invalid_integrity_chosen_path(
+                            updated_item.get_label_as_file(),
+                        )
+
                     api.save(updated_item, ActionDescription.EDITION)
 
                     # This case is the default "file title and description update"
 
                     if isinstance(file_data, FieldStorage):
                         api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
+
+                        # Display error page to user if chosen label is in
+                        # conflict
+                        if not self._path_validation.validate_new_content(
+                            item,
+                        ):
+                            return render_invalid_integrity_chosen_path(
+                                item.get_label_as_file(),
+                            )
+
                         api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
 
         api = ContentApi(tmpl_context.current_user)
 
-        page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
-        page.description = content
+        with DBSession.no_autoflush:
+            page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
+            page.description = content
+
+            if not self._path_validation.validate_new_content(page):
+                return render_invalid_integrity_chosen_path(
+                    page.get_label(),
+                )
+
         api.save(page, ActionDescription.CREATION, do_notify=True)
 
         tg.flash(_('Page created'), CST.STATUS_OK)
             item = api.get_one(int(item_id), self._item_type, workspace)
             with new_revision(item):
                 api.update_content(item, label, content)
+
+                if not self._path_validation.validate_new_content(item):
+                    return render_invalid_integrity_chosen_path(
+                        item.get_label(),
+                    )
+
                 api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
 
         api = ContentApi(tmpl_context.current_user)
 
-        thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
-        # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
-        api.save(thread, ActionDescription.CREATION, do_notify=False)
+        with DBSession.no_autoflush:
+            thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
+            # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
+            api.save(thread, ActionDescription.CREATION, do_notify=False)
+
+            comment = api.create(ContentType.Comment, workspace, thread, label)
+            comment.label = ''
+            comment.description = content
+
+            if not self._path_validation.validate_new_content(thread):
+                return render_invalid_integrity_chosen_path(
+                    thread.get_label(),
+                )
 
-        comment = api.create(ContentType.Comment, workspace, thread, label)
-        comment.label = ''
-        comment.description = content
         api.save(comment, ActionDescription.COMMENT, do_notify=False)
         api.do_notify(thread)
 
             parent = None
             if parent_id:
                 parent = api.get_one(int(parent_id), ContentType.Folder, workspace)
-            folder = api.create(ContentType.Folder, workspace, parent, label)
 
-            subcontent = dict(
-                folder = True if can_contain_folders=='on' else False,
-                thread = True if can_contain_threads=='on' else False,
-                file = True if can_contain_files=='on' else False,
-                page = True if can_contain_pages=='on' else False
-            )
-            api.set_allowed_content(folder, subcontent)
+            with DBSession.no_autoflush:
+                folder = api.create(ContentType.Folder, workspace, parent, label)
+
+                subcontent = dict(
+                    folder = True if can_contain_folders=='on' else False,
+                    thread = True if can_contain_threads=='on' else False,
+                    file = True if can_contain_files=='on' else False,
+                    page = True if can_contain_pages=='on' else False
+                )
+                api.set_allowed_content(folder, subcontent)
+
+                if not self._path_validation.validate_new_content(folder):
+                    return render_invalid_integrity_chosen_path(
+                        folder.get_label(),
+                    )
+
             api.save(folder)
 
             tg.flash(_('Folder created'), CST.STATUS_OK)
                     # TODO - D.A. - 2015-05-25 - Allow to set folder description
                     api.update_content(folder, label, folder.description)
                 api.set_allowed_content(folder, subcontent)
+
+                if not self._path_validation.validate_new_content(folder):
+                    return render_invalid_integrity_chosen_path(
+                        folder.get_label(),
+                    )
+
                 api.save(folder)
 
             tg.flash(_('Folder updated'), CST.STATUS_OK)

tracim/tracim/fixtures/content.py

             with_notif=False,
         )
 
+        # Folders
         w1f1 = content_api.create(
             content_type=ContentType.Folder,
             workspace=w1,
             do_save=True,
         )
 
-        # Folders
         w2f1 = content_api.create(
             content_type=ContentType.Folder,
             workspace=w2,
-            label='w1f1',
+            label='w2f1',
             do_save=True,
         )
         w2f2 = content_api.create(
         )
         w1f1t1.description = 'w1f1t1 description'
         self._session.add(w1f1t1)
-        w1f1d1 = content_api.create(
+        w1f1d1_txt = content_api.create(
             content_type=ContentType.File,
             workspace=w1,
             parent=w1f1,
             label='w1f1d1',
             do_save=False,
         )
-        w1f1d1.file_extension = '.txt'
-        w1f1d1.file_content = b'w1f1d1 content'
-        self._session.add(w1f1d1)
+        w1f1d1_txt.file_extension = '.txt'
+        w1f1d1_txt.file_content = b'w1f1d1 content'
+        self._session.add(w1f1d1_txt)
+        w1f1d2_html = content_api.create(
+            content_type=ContentType.File,
+            workspace=w1,
+            parent=w1f1,
+            label='w1f1d2',
+            do_save=False,
+        )
+        w1f1d2_html.file_extension = '.html'
+        w1f1d2_html.file_content = b'<p>w1f1d2 content</p>'
+        self._session.add(w1f1d2_html)
+        w1f1f1 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w1,
+            label='w1f1f1',
+            parent=w1f1,
+            do_save=True,
+        )
 
         w2f1p1 = content_api.create(
             content_type=ContentType.Page,

tracim/tracim/lib/content.py

 import os
 
 from operator import itemgetter
+from sqlalchemy import func
+from sqlalchemy.orm import Query
 
 __author__ = 'damien'
 
 
         return result
 
+    def get_base_query(self, workspace: Workspace) -> Query:
+        return self._base_query(workspace)
+
     def get_child_folders(self, parent: Content=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[], allowed_node_types=None) -> [Content]:
         """
         This method returns child items (folders or items) for left bar treeview.
         content.is_temporary = is_temporary
         content.revision_type = ActionDescription.CREATION
 
+        if content.type in (
+                ContentType.Page,
+                ContentType.Thread,
+        ):
+            content.file_extension = '.html'
+
         if do_save:
             DBSession.add(content)
             self.save(content, ActionDescription.CREATION)
             content_parent_labels: [str]=None,
     ):
         """
-        TODO: Assurer l'unicité des path dans Tracim
-        TODO: Ecrire tous les cas de tests par rapports aux
-         cas d'erreurs possible (duplications de labels, etc) et TROUVES
         Return content with it's label, workspace and parents labels (optional)
         :param content_label: label of content (label or file_name)
         :param workspace: workspace containing all of this
         :return: Found Content
         """
         query = self._base_query(workspace)
-        file_name, file_extension = os.path.splitext(content_label)
         parent_folder = None
 
         # Grab content parent folder if parent path given
             )
 
         # Build query for found content by label
-        content_query = query.filter(or_(
-            and_(
-                Content.type == ContentType.File,
-                Content.label == file_name,
-                Content.file_extension == file_extension,
-            ),
-            and_(
-                Content.type == ContentType.Thread,
-                Content.label == file_name,
-            ),
-            and_(
-                Content.type == ContentType.Page,
-                Content.label == file_name,
-            ),
-            and_(
-                Content.type == ContentType.Folder,
-                Content.label == content_label,
-            ),
-        ))
+        content_query = self.filter_query_for_content_label_as_path(
+            query=query,
+            content_label_as_file=content_label,
+        )
 
         # Modify query to apply parent folder filter if any
         if parent_folder:
             content_query = content_query.filter(
                 Content.parent_id == parent_folder.content_id,
-                Content.workspace_id == workspace.workspace_id,
             )
 
+        # Filter with workspace
+        content_query = content_query.filter(
+            Content.workspace_id == workspace.workspace_id,
+        )
+
         # Return the content
         return content_query\
             .order_by(
 
         return folder
 
+    def filter_query_for_content_label_as_path(
+            self,
+            query: Query,
+            content_label_as_file: str,
+            is_case_sensitive: bool = False,
+    ) -> Query:
+        """
+        Apply normalised filters to found Content corresponding as given label.
+        :param query: query to modify
+        :param content_label_as_file: label in this
+        FILE version, use Content.get_label_as_file().
+        :param is_case_sensitive: Take care about case or not
+        :return: modified query
+        """
+        file_name, file_extension = os.path.splitext(content_label_as_file)
+
+        label_filter = Content.label == content_label_as_file
+        file_name_filter = Content.label == file_name
+        file_extension_filter = Content.file_extension == file_extension
+
+        if not is_case_sensitive:
+            label_filter = func.lower(Content.label) == \
+                           func.lower(content_label_as_file)
+            file_name_filter = func.lower(Content.label) == \
+                               func.lower(file_name)
+            file_extension_filter = func.lower(Content.file_extension) == \
+                                    func.lower(file_extension)
+
+        return query.filter(or_(
+            and_(
+                Content.type == ContentType.File,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Thread,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Page,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Folder,
+                label_filter,
+            ),
+        ))
+
     def get_all(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> [Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
         assert content_type is not None# DYN_REMOVE

tracim/tracim/lib/integrity.py

+# -*- coding: utf-8 -*-
+import os
+
+from sqlalchemy import func
+from tg import tmpl_context
+from tg.render import render
+from tracim.lib.content import ContentApi
+from tracim.lib.workspace import UnsafeWorkspaceApi
+from tracim.model.data import Workspace
+from tracim.model.data import Content
+from tracim.model.serializers import DictLikeClass, Context, CTX
+
+
+class PathValidationManager(object):
+    def __init__(self, is_case_sensitive: bool=False):
+        """
+        :param is_case_sensitive: If True, consider name with different
+        case as different.
+        """
+        self._is_case_sensitive = is_case_sensitive
+        self._workspace_api = UnsafeWorkspaceApi(None)
+        self._content_api = ContentApi(None)
+
+    def workspace_label_is_free(self, workspace_name: str) -> bool:
+        """
+        :param workspace_name: Workspace name
+        :return: True if workspace is available
+        """
+        query = self._workspace_api.get_base_query()
+
+        label_filter = Workspace.label == workspace_name
+        if not self._is_case_sensitive:
+            label_filter = func.lower(Workspace.label) == \
+                           func.lower(workspace_name)
+
+        return not bool(query.filter(label_filter).count())
+
+    def content_label_is_free(
+            self,
+            content_label_as_file,
+            workspace: Workspace,
+            parent: Content=None,
+            exclude_content_id: int=None,
+    ) -> bool:
+        """
+        :param content_label_as_file:
+        :param workspace:
+        :param parent:
+        :return: True if content label is available
+        """
+        query = self._content_api.get_base_query(workspace)
+
+        if parent:
+            query = query.filter(Content.parent_id == parent.content_id)
+
+        if exclude_content_id:
+            query = query.filter(Content.content_id != exclude_content_id)
+
+        query = query.filter(Content.workspace_id == workspace.workspace_id)
+
+        return not \
+            bool(
+                self._content_api.filter_query_for_content_label_as_path(
+                    query=query,
+                    content_label_as_file=content_label_as_file,
+                    is_case_sensitive=self._is_case_sensitive,
+                ).count()
+            )
+
+    def validate_new_content(self, content: Content) -> bool:
+        """
+        :param content: Content with label to test
+        :return: True if content label is not in conflict with existing
+        resource
+        """
+        return self.content_label_is_free(
+            content_label_as_file=content.get_label_as_file(),
+            workspace=content.workspace,
+            parent=content.parent,
+            exclude_content_id=content.content_id,
+        )
+
+
+def render_invalid_integrity_chosen_path(invalid_label: str) -> str:
+    """
+    Return html page code of error about invalid label choice.
+    :param invalid_label: the invalid label
+    :return: html page code
+    """
+    user = tmpl_context.current_user
+    fake_api_content = DictLikeClass(
+        current_user=user,
+    )
+    fake_api = Context(CTX.USER).toDict(fake_api_content)
+
+    return render(
+        template_vars=dict(
+            invalid_label=invalid_label,
+            fake_api=fake_api,
+        ),
+        template_engine='mako',
+        template_name='tracim.templates.errors.label_invalid_path',
+    )

tracim/tracim/lib/workspace.py

 # -*- coding: utf-8 -*-
 import transaction
+from sqlalchemy.orm import Query
 
 from tracim.lib.userworkspace import RoleApi
 from tracim.model.auth import Group
                 related_object_id=workspace.workspace_id,
             )
 
+    def get_base_query(self) -> Query:
+        return self._base_query()
+
 
 class UnsafeWorkspaceApi(WorkspaceApi):
     def _base_query(self):

tracim/tracim/model/data.py

         return False
 
     def get_label_as_file(self):
-        file_extension = self.file_extension
+        file_extension = self.file_extension or ''
 
         if self.type == ContentType.Thread:
             file_extension = '.html'
     @file_name.setter
     def file_name(self, value: str) -> None:
         file_name, file_extension = os.path.splitext(value)
-        self.revision.label = file_name
+        if not self.revision.label:
+            self.revision.label = file_name
         self.revision.file_extension = file_extension
 
     @file_name.expression

tracim/tracim/templates/errors/__init__.py

+# -*- coding: utf-8 -*-

tracim/tracim/templates/errors/label_invalid_path.mak

+<%inherit file="local:templates.master_authenticated"/>
+
+<div class="row">
+    <div class="col-sm-7 col-sm-offset-3 main">
+        <p>
+            ${_('Chosen label "{0}" is invalid because is in conflict with other resource.').format(invalid_label)}
+        </p>
+
+        <button onclick="goBack()">${_('Go Back')}</button>
+
+        <script>
+        function goBack() {
+            window.history.back();
+        }
+        </script>
+
+    </div>
+</div>

tracim/tracim/tests/library/test_content_api.py

         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
-        eq_('index.html', updated.file_name)
+        eq_('this_is_a_page.html', updated.file_name)
         eq_('text/html', updated.file_mimetype)
         eq_(b'<html>hello world</html>', updated.file_content)
         eq_(ActionDescription.REVISION, updated.revision_type)

tracim/tracim/tests/library/test_integrity.py

+# -*- coding: utf-8 -*-
+from nose.tools import ok_
+
+from tracim.fixtures.content import Content as ContentFixtures
+from tracim.lib.integrity import PathValidationManager
+from tracim.model import DBSession
+from tracim.model.data import Workspace
+from tracim.model.data import Content
+from tracim.model.data import ContentRevisionRO
+from tracim.tests import TestStandard
+
+
+class TestWebDav(TestStandard):
+    fixtures = [ContentFixtures]
+
+    def _get_content_by_label(self, label: str) -> Content:
+        revision = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.label == label) \
+            .one()
+
+        return DBSession.query(Content) \
+            .filter(Content.id == revision.content_id) \
+            .one()
+
+    def test_unit__workspace_label_available__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            integrity_manager.workspace_label_is_free('w42'),
+            msg='label w42 should not be used',
+        )
+
+    def test_unit__workspace_label_reserved__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            not integrity_manager.workspace_label_is_free('w1'),
+            msg='label w1 should be reserved',
+        )
+
+    def test_unit__workspace_label_reserved_with_case__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            not integrity_manager.workspace_label_is_free('W1'),
+            msg='label W1 should be reserved',
+        )
+
+    def test_unit__folder_label_available__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='f42',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label f42 should not be used',
+        )
+
+    def test_unit__folder_label_reserved__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label w1f1 should be reserved',
+        )
+
+    def test_unit__folder_label_reserved_with_case__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='W1F1',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label W1F1 should be reserved',
+        )
+
+    def test_unit__folder_label_reserved__ok__folder_in_folder(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1f1',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1f1 should be reserved',
+        )
+
+    def test_unit__content_label_reserved__ok__because_page_name(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p1.html should be reserved '
+                'because page w1f1p1.html',
+        )
+
+    def test_unit__content_label_available__ok(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p42.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p42.html should be available',
+        )
+
+    def test_unit__content_label_available__ok__without_extension(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p42',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p42 should be available',
+        )
+
+    def test_unit__content_label_reserved__ok(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p1.html should be reserved',
+        )
+
+    def test_unit__content_label_reserved__ok__because_thread_extension(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1t1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1t1 should be reserved because '
+                'w1f1t1 rendered with .html',
+        )
+
+    def test_unit__content_label_reserved__ok__because_html_file(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1d2.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1d2.html should be reserved because '
+                'w1f1d2 rendered with .html and file w1f1d2.html exist',
+        )

tracim/tracim/tests/library/test_webdav.py

 
         children = w1f1.getMemberList()
         eq_(
-            3,
+            5,
             len(children),
-            msg='w1f1 should list 3 folders instead {0}'.format(
+            msg='w1f1 should list 5 folders instead {0}'.format(
                 len(children),
             ),
         )
                 content_names,
             )
         )
+        ok_(
+            'w1f1f1' in content_names,
+            msg='w1f1f1 should be in names ({0})'.format(
+                content_names,
+            )
+        )
+        ok_(
+            'w1f1d2.html' in content_names,
+            msg='w1f1d2.html should be in names ({0})'.format(
+                content_names,
+            )
+        )
 
     def test_unit__get_content__ok(self):
         provider = self._get_provider()