django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/knowledge/auth/tests/test_controller.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.test import RequestFactory
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.auth.controller import BaseKnowledgeAuthController
+from django_spire.knowledge.collection.models import Collection
+
+
+class BaseKnowledgeAuthControllerTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.factory = RequestFactory()
+        self.user = create_user(username='test_auth_user')
+        self.request = self.factory.get('/')
+        self.request.user = self.user
+
+        content_type = ContentType.objects.get_for_model(Collection)
+
+        self.view_permission = Permission.objects.get(
+            codename='view_collection',
+            content_type=content_type
+        )
+        self.add_permission = Permission.objects.get(
+            codename='add_collection',
+            content_type=content_type
+        )
+        self.change_permission = Permission.objects.get(
+            codename='change_collection',
+            content_type=content_type
+        )
+        self.delete_permission = Permission.objects.get(
+            codename='delete_collection',
+            content_type=content_type
+        )
+        self.access_all_permission = Permission.objects.get(
+            codename='can_access_all_collections',
+            content_type=content_type
+        )
+        self.change_groups_permission = Permission.objects.get(
+            codename='can_change_collection_groups',
+            content_type=content_type
+        )
+
+    def _refresh_user_and_request(self):
+        self.user = type(self.user).objects.get(pk=self.user.pk)
+        self.request.user = self.user
+
+    def test_can_view_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_view() is False
+
+    def test_can_view_with_permission(self):
+        self.user.user_permissions.add(self.view_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_view() is True
+
+    def test_can_add_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_add() is False
+
+    def test_can_add_with_permission(self):
+        self.user.user_permissions.add(self.add_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_add() is True
+
+    def test_can_change_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_change() is False
+
+    def test_can_change_with_permission(self):
+        self.user.user_permissions.add(self.change_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_change() is True
+
+    def test_can_delete_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_delete() is False
+
+    def test_can_delete_with_permission(self):
+        self.user.user_permissions.add(self.delete_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_delete() is True
+
+    def test_can_access_all_collections_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_access_all_collections() is False
+
+    def test_can_access_all_collections_with_permission(self):
+        self.user.user_permissions.add(self.access_all_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_access_all_collections() is True
+
+    def test_can_change_collection_groups_without_permission(self):
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_change_collection_groups() is False
+
+    def test_can_change_collection_groups_with_permission(self):
+        self.user.user_permissions.add(self.change_groups_permission)
+        self._refresh_user_and_request()
+
+        controller = BaseKnowledgeAuthController(self.request)
+        assert controller.can_change_collection_groups() is True

django_spire/knowledge/collection/admin.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django.contrib import admin
-from django.db.models import QuerySet
 from django.contrib import messages
 
 from .models import Collection, CollectionGroup
 
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
 
 @admin.register(Collection)
 class CollectionAdmin(admin.ModelAdmin):

django_spire/knowledge/collection/models.py

@@ -9,8 +9,10 @@ from django_spire.core.tag.mixins import TagModelMixin
 from django_spire.contrib.utils import truncate_string
 from django_spire.history.mixins import HistoryModelMixin
 from django_spire.knowledge.collection.querysets import CollectionQuerySet
-from django_spire.knowledge.collection.services.service import CollectionGroupService, \
+from django_spire.knowledge.collection.services.service import (
+    CollectionGroupService,
     CollectionService
+)
 
 
 class Collection(

django_spire/knowledge/collection/seeding/seed.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from django_spire.knowledge.collection.seeding.seeder import CollectionSeeder
 
+
 parent_collections = CollectionSeeder.seed_database(count=5)
 child_collections = CollectionSeeder.seed_child_collections(count=15)
 

django_spire/knowledge/collection/services/factory_service.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from django.core.handlers.wsgi import WSGIRequest
-
 from django_spire.auth.controller.controller import AppAuthController
 from django_spire.contrib.service import BaseDjangoModelService
 
 if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
     from django_spire.knowledge.collection.models import Collection, CollectionGroup
 
 
@@ -15,10 +15,10 @@ class CollectionGroupFactoryService(BaseDjangoModelService['CollectionGroup']):
     obj: CollectionGroup
 
     def replace_groups(
-            self,
-            request: WSGIRequest,
-            group_pks: list[int] | None,
-            collection: Collection
+        self,
+        request: WSGIRequest,
+        group_pks: list[int] | None,
+        collection: Collection
     ) -> list[CollectionGroup]:
         if not AppAuthController('knowledge', request).can_change_collection_groups():
             return []
@@ -28,11 +28,10 @@ class CollectionGroupFactoryService(BaseDjangoModelService['CollectionGroup']):
 
         old_collection_groups = list(collection.groups.all())
 
-        new_collection_groups = []
-        for group_pk in group_pks:
-            new_collection_groups.append(
-                self.obj_class(auth_group_id=group_pk, collection=collection)
-            )
+        new_collection_groups = [
+            self.obj_class(auth_group_id=group_pk, collection=collection)
+            for group_pk in group_pks
+        ]
 
         self.obj_class.objects.bulk_create(new_collection_groups)
 

django_spire/knowledge/collection/services/ordering_service.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from django_spire.contrib.service import BaseDjangoModelService
-
 from typing import TYPE_CHECKING
 
+from django_spire.contrib.service import BaseDjangoModelService
 
 if TYPE_CHECKING:
     from django_spire.knowledge.collection.models import Collection

django_spire/knowledge/collection/services/service.py

@@ -4,17 +4,12 @@ from django_spire.contrib.service import BaseDjangoModelService
 
 from typing import TYPE_CHECKING
 
-from django_spire.knowledge.collection.services.factory_service import \
-    CollectionGroupFactoryService
-from django_spire.knowledge.collection.services.ordering_service import \
-    CollectionOrderingService
-from django_spire.knowledge.collection.services.processor_service import \
-    CollectionProcessorService
+from django_spire.knowledge.collection.services.factory_service import CollectionGroupFactoryService
+from django_spire.knowledge.collection.services.ordering_service import CollectionOrderingService
+from django_spire.knowledge.collection.services.processor_service import CollectionProcessorService
 from django_spire.knowledge.collection.services.tag_service import CollectionTagService
-from django_spire.knowledge.collection.services.tool_services import \
-    CollectionToolService
-from django_spire.knowledge.collection.services.transformation_service import \
-    CollectionTransformationService
+from django_spire.knowledge.collection.services.tool_services import CollectionToolService
+from django_spire.knowledge.collection.services.transformation_service import CollectionTransformationService
 
 if TYPE_CHECKING:
     from django_spire.knowledge.collection.models import Collection, CollectionGroup

django_spire/knowledge/collection/services/tag_service.py

@@ -6,8 +6,11 @@ from dandy import Prompt
 
 from django_spire.core.tag.intelligence.tag_set_bot import TagSetBot
 from django_spire.core.tag.service.tag_service import BaseTagService
-from django_spire.core.tag.tools import simplify_tag_set, simplify_and_weight_tag_set_to_dict, \
-    get_score_percentage_from_tag_set_weighted
+from django_spire.core.tag.tools import (
+    get_score_percentage_from_tag_set_weighted,
+    simplify_and_weight_tag_set_to_dict,
+    simplify_tag_set
+)
 
 if TYPE_CHECKING:
     from django_spire.knowledge.collection.models import Collection

django_spire/knowledge/collection/tests/factories.py

@@ -1,6 +1,15 @@
 from __future__ import annotations
 
-from django_spire.knowledge.collection.models import Collection
+from django_spire.auth.group.models import AuthGroup
+from django_spire.knowledge.collection.models import Collection, CollectionGroup
+
+
+def create_test_auth_group(**kwargs) -> AuthGroup:
+    data = {
+        'name': 'Test Group',
+    }
+    data.update(kwargs)
+    return AuthGroup.objects.create(**data)
 
 
 def create_test_collection(**kwargs) -> Collection:
@@ -13,3 +22,21 @@ def create_test_collection(**kwargs) -> Collection:
     }
     data.update(kwargs)
     return Collection.objects.create(**data)
+
+
+def create_test_collection_group(
+    collection: Collection | None = None,
+    auth_group: AuthGroup | None = None,
+    **kwargs
+) -> CollectionGroup:
+    if collection is None:
+        collection = create_test_collection()
+    if auth_group is None:
+        auth_group = create_test_auth_group()
+
+    data = {
+        'collection': collection,
+        'auth_group': auth_group,
+    }
+    data.update(kwargs)
+    return CollectionGroup.objects.create(**data)

django_spire/knowledge/collection/tests/test_models.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.tests.factories import (
+    create_test_collection,
+    create_test_collection_group,
+)
+
+
+class CollectionModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.collection = create_test_collection()
+
+    def test_str(self):
+        assert str(self.collection) == self.collection.name
+
+    def test_name_short_truncates(self):
+        long_name = 'A' * 100
+        collection = create_test_collection(name=long_name)
+        assert len(collection.name_short) <= 35
+
+    def test_name_short_no_truncate(self):
+        short_name = 'Short'
+        collection = create_test_collection(name=short_name)
+        assert collection.name_short == short_name
+
+    def test_top_level_parent_returns_self_when_no_parent(self):
+        assert self.collection.top_level_parent == self.collection
+
+    def test_top_level_parent_returns_root(self):
+        child = create_test_collection(parent=self.collection, name='Child')
+        grandchild = create_test_collection(parent=child, name='Grandchild')
+        assert grandchild.top_level_parent == self.collection
+
+    def test_base_breadcrumb(self):
+        breadcrumbs = self.collection.base_breadcrumb()
+        assert breadcrumbs is not None
+
+
+class CollectionGroupModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.collection_group = create_test_collection_group()
+
+    def test_str(self):
+        expected = f'{self.collection_group.collection.name} - {self.collection_group.auth_group.name}'
+        assert str(self.collection_group) == expected

django_spire/knowledge/collection/tests/test_querysets.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from django.test import RequestFactory
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.models import Collection
+from django_spire.knowledge.collection.tests.factories import (
+    create_test_auth_group,
+    create_test_collection,
+    create_test_collection_group,
+)
+
+
+class CollectionQuerySetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.factory = RequestFactory()
+        self.user = create_user(username='test_queryset_user')
+        self.parent_collection = create_test_collection(name='Parent')
+        self.child_collection = create_test_collection(
+            parent=self.parent_collection,
+            name='Child'
+        )
+
+    def test_by_parent(self):
+        result = Collection.objects.by_parent(parent=self.parent_collection)
+        assert self.child_collection in result
+        assert self.parent_collection not in result
+
+    def test_by_parent_id(self):
+        result = Collection.objects.by_parent_id(parent_id=self.parent_collection.id)
+        assert self.child_collection in result
+
+    def test_by_parent_ids(self):
+        result = Collection.objects.by_parent_ids(parent_ids=[self.parent_collection.id])
+        assert self.child_collection in result
+
+    def test_parentless(self):
+        result = Collection.objects.parentless()
+        assert self.parent_collection in result
+        assert self.child_collection not in result
+
+    def test_childless(self):
+        grandchild = create_test_collection(
+            parent=self.child_collection,
+            name='Grandchild'
+        )
+        result = Collection.objects.childless()
+        assert grandchild in result
+        assert self.parent_collection not in result
+
+    def test_children(self):
+        grandchild = create_test_collection(
+            parent=self.child_collection,
+            name='Grandchild'
+        )
+        result = Collection.objects.children(collection_id=self.parent_collection.id)
+        assert self.child_collection in result
+        assert grandchild in result
+
+    def test_exclude_children(self):
+        grandchild = create_test_collection(
+            parent=self.child_collection,
+            name='Grandchild'
+        )
+        result = Collection.objects.exclude_children(collection_id=self.parent_collection.id)
+        assert self.parent_collection in result
+        assert self.child_collection not in result
+        assert grandchild not in result
+
+    def test_annotate_entry_count(self):
+        result = Collection.objects.annotate_entry_count()
+        assert result.first().entry_count == 0
+
+    def test_request_user_has_access_superuser(self):
+        request = self.factory.get('/')
+        request.user = self.super_user
+        result = Collection.objects.request_user_has_access(request)
+        assert self.parent_collection in result
+
+    def test_request_user_has_access_with_group(self):
+        auth_group = create_test_auth_group(name='Access Group')
+        self.user.groups.add(auth_group)
+        create_test_collection_group(
+            collection=self.parent_collection,
+            auth_group=auth_group
+        )
+
+        request = self.factory.get('/')
+        request.user = self.user
+        result = Collection.objects.request_user_has_access(request)
+        assert self.parent_collection in result

django_spire/knowledge/collection/tests/test_services/test_factory_service.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.test import RequestFactory
+
+from django_spire.auth.user.tests.factories import create_user
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.models import Collection, CollectionGroup
+from django_spire.knowledge.collection.tests.factories import (
+    create_test_auth_group,
+    create_test_collection,
+    create_test_collection_group,
+)
+
+
+class CollectionGroupFactoryServiceTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.factory = RequestFactory()
+        self.user = create_user(username='test_factory_user')
+        self.collection = create_test_collection()
+        self.auth_group1 = create_test_auth_group(name='Group 1')
+        self.auth_group2 = create_test_auth_group(name='Group 2')
+
+        content_type = ContentType.objects.get_for_model(Collection)
+        self.change_groups_permission = Permission.objects.get(
+            codename='can_change_collection_groups',
+            content_type=content_type
+        )
+
+    def _refresh_user(self):
+        self.user = type(self.user).objects.get(pk=self.user.pk)
+
+    def test_replace_groups_without_permission(self):
+        request = self.factory.get('/')
+        request.user = self.user
+
+        result = CollectionGroup.services.factory.replace_groups(
+            request=request,
+            group_pks=[self.auth_group1.pk],
+            collection=self.collection
+        )
+        assert result == []
+
+    def test_replace_groups_with_permission(self):
+        self.user.user_permissions.add(self.change_groups_permission)
+        self._refresh_user()
+
+        request = self.factory.get('/')
+        request.user = self.user
+
+        result = CollectionGroup.services.factory.replace_groups(
+            request=request,
+            group_pks=[self.auth_group1.pk, self.auth_group2.pk],
+            collection=self.collection
+        )
+        assert len(result) == 2
+        assert self.collection.groups.count() == 2
+
+    def test_replace_groups_removes_old(self):
+        self.user.user_permissions.add(self.change_groups_permission)
+        self._refresh_user()
+
+        create_test_collection_group(
+            collection=self.collection,
+            auth_group=self.auth_group1
+        )
+
+        request = self.factory.get('/')
+        request.user = self.user
+
+        CollectionGroup.services.factory.replace_groups(
+            request=request,
+            group_pks=[self.auth_group2.pk],
+            collection=self.collection
+        )
+
+        assert self.collection.groups.count() == 1
+        assert self.collection.groups.first().auth_group == self.auth_group2
+
+    def test_replace_groups_with_none_deletes_all(self):
+        self.user.user_permissions.add(self.change_groups_permission)
+        self._refresh_user()
+
+        create_test_collection_group(
+            collection=self.collection,
+            auth_group=self.auth_group1
+        )
+
+        request = self.factory.get('/')
+        request.user = self.user
+
+        CollectionGroup.services.factory.replace_groups(
+            request=request,
+            group_pks=None,
+            collection=self.collection
+        )
+
+        assert self.collection.groups.count() == 0