Search: exclude content under archived or deleted parents

tracim/tracim/controllers/root.py

         result = api.search(keyword_list)
         if result:
             items = result.limit(ContentApi.SEARCH_DEFAULT_RESULT_NB).all()
+        api.exclude_unavailable(items)
 
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         fake_api = Context(CTX.CURRENT_USER).toDict({'current_user': current_user_content})

tracim/tracim/lib/content.py

 
         return ContentType.sorted(content_types)
 
+    def exclude_unavailable(self, contents: [Content]) -> [Content]:
+        """
+        Update and return list with content under archived/deleted removed.
+        :param contents: List of contents to parse
+        """
+        for content in contents[:]:
+            if self.content_under_deleted(content) or self.content_under_archived(content):
+                contents.remove(content)
+        return contents
+
+    def content_under_deleted(self, content: Content) -> bool:
+        if content.parent:
+            if content.parent.is_deleted:
+                return True
+            if content.parent.parent:
+                return self.content_under_deleted(content.parent)
+        return False
+
+    def content_under_archived(self, content: Content) -> bool:
+        if content.parent:
+            if content.parent.is_archived:
+                return True
+            if content.parent.parent:
+                return self.content_under_archived(content.parent)
+        return False

tracim/tracim/tests/__init__.py

 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from tracim.lib.base import logger
 from tracim.lib.content import ContentApi
+from tracim.lib.workspace import WorkspaceApi
 from tracim.model import DBSession, Content
 from tracim.model.data import Workspace, ContentType, ContentRevisionRO
 
 
 class BaseTest(object):
 
-    def _create_workspace_and_test(self, name, *args, **kwargs) -> Workspace:
+    def _create_workspace_and_test(self, name, user) -> Workspace:
         """
         All extra parameters (*args, **kwargs) are for Workspace init
         :return: Created workspace instance
         """
-        workspace = Workspace(label=name, *args, **kwargs)
-        DBSession.add(workspace)
-        DBSession.flush()
+        WorkspaceApi(user).create_workspace(name, save_now=True)
 
         eq_(1, DBSession.query(Workspace).filter(Workspace.label == name).count())
         return DBSession.query(Workspace).filter(Workspace.label == name).one()
 
 class BaseTestThread(BaseTest):
 
-    def _create_thread_and_test(self, workspace_name='workspace_1', folder_name='folder_1', thread_name='thread_1') -> Content:
+    def _create_thread_and_test(self,
+                                user,
+                                workspace_name='workspace_1',
+                                folder_name='folder_1',
+                                thread_name='thread_1') -> Content:
         """
         :return: Thread
         """
-        workspace = self._create_workspace_and_test(workspace_name)
-        folder = self._create_content_and_test(folder_name, workspace, type=ContentType.Folder)
-        thread = self._create_content_and_test(thread_name, workspace, type=ContentType.Thread, parent=folder)
+        workspace = self._create_workspace_and_test(workspace_name, user)
+        folder = self._create_content_and_test(folder_name, workspace, type=ContentType.Folder, owner=user)
+        thread = self._create_content_and_test(thread_name,
+                                               workspace,
+                                               type=ContentType.Thread,
+                                               parent=folder,
+                                               owner=user)
         return thread

tracim/tracim/tests/library/test_content_api.py

 # -*- coding: utf-8 -*-
 
-from nose.tools import eq_
+from nose.tools import eq_, ok_
 from nose.tools import raises
 from tracim.lib.group import GroupApi
 
 from tracim.lib.user import UserApi
 from tracim.lib.workspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
-from tracim.model import DBSession, new_revision
+from tracim.model import DBSession, new_revision, User
 
 from tracim.model.auth import Group
 
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
 
-from tracim.tests import TestStandard
+from tracim.tests import TestStandard, BaseTest
 
 
-class TestContentApi(TestStandard):
+class TestContentApi(BaseTest, TestStandard):
 
     def test_compare_content_for_sorting_by_type(self):
         c1 = Content()
 
         eq_(True, id1 in [o.content_id for o in res.all()])
         eq_(True, id2 in [o.content_id for o in res.all()])
+
+    def test_unit__search_exclude_content_under_deleted_or_archived_parents__ok(self):
+        admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
+        workspace = self._create_workspace_and_test('workspace_1', admin)
+        folder_1 = self._create_content_and_test('folder_1', workspace=workspace, type=ContentType.Folder)
+        folder_2 = self._create_content_and_test('folder_2', workspace=workspace, type=ContentType.Folder)
+        page_1 = self._create_content_and_test('foo', workspace=workspace, type=ContentType.Page, parent=folder_1)
+        page_2 = self._create_content_and_test('bar', workspace=workspace, type=ContentType.Page, parent=folder_2)
+
+        api = ContentApi(admin)
+
+        foo_result = api.search(['foo']).all()
+        eq_(1, len(foo_result))
+        ok_(page_1 in foo_result)
+
+        bar_result = api.search(['bar']).all()
+        eq_(1, len(bar_result))
+        ok_(page_2 in bar_result)
+
+        with new_revision(folder_1):
+            api.delete(folder_1)
+        with new_revision(folder_2):
+            api.archive(folder_2)
+
+        # Actually ContentApi.search don't filter it
+        foo_result = api.search(['foo']).all()
+        eq_(1, len(foo_result))
+        ok_(page_1 in foo_result)
+
+        bar_result = api.search(['bar']).all()
+        eq_(1, len(bar_result))
+        ok_(page_2 in bar_result)
+
+        # ContentApi offer exclude_unavailable method to do it
+        foo_result = api.search(['foo']).all()
+        api.exclude_unavailable(foo_result)
+        eq_(0, len(foo_result))
+
+        bar_result = api.search(['bar']).all()
+        api.exclude_unavailable(bar_result)
+        eq_(0, len(bar_result))

tracim/tracim/tests/library/test_thread.py

 import transaction
 from nose.tools import eq_
 
+from tracim.model import DBSession, User
 from tracim.tests import BaseTestThread, TestStandard
 
 
 class TestThread(BaseTestThread, TestStandard):
 
     def test_create_thread(self, key='1'):
+        admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
         return self._create_thread_and_test(
             workspace_name='workspace_%s' % key,
             folder_name='folder_%s' % key,
             thread_name='thread_%s' % key,
+            user=admin
         )

tracim/tracim/tests/library/test_workspace.py

 from nose.tools import eq_
 
 from tracim.lib.content import ContentApi
-from tracim.model import DBSession, Content
+from tracim.model import DBSession, Content, User
 from tracim.model.data import Workspace
 from tracim.tests import BaseTestThread, TestStandard
 
 class TestThread(BaseTestThread, TestStandard):
 
     def test_children(self):
+        admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
         self._create_thread_and_test(
             workspace_name='workspace_1',
             folder_name='folder_1',
             thread_name='thread_1',
+            user=admin
         )
         workspace = DBSession.query(Workspace).filter(Workspace.label == 'workspace_1').one()
         folder = ContentApi.get_canonical_query().filter(Content.label == 'folder_1').one()

tracim/tracim/tests/models/test_content_revision.py

 
     def test_new_revision(self):
         admin = DBSession.query(User).filter(User.email == 'admin@admin.admin').one()
-        workspace = self._create_workspace_and_test(name='workspace_1')
+        workspace = self._create_workspace_and_test(name='workspace_1', user=admin)
         folder = self._create_content_and_test(name='folder_1', workspace=workspace, type=ContentType.Folder)
         page = self._create_content_and_test(
             workspace=workspace,