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

django_spire/file/interfaces.py

@@ -5,16 +5,16 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from django.conf import settings
-from django.core.files.base import ContentFile
-
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.files.base import ContentFile
 
 from django_spire.file.models import File
 from django_spire.file.utils import random_64_char_token
 
 if TYPE_CHECKING:
     from django.core.files.uploadedfile import InMemoryUploadedFile
+
     from django_spire.file.mixins import FileModelMixin
 
 
@@ -26,7 +26,7 @@ class FileFormatter:
     type: str = ...
     app_name: str = 'Uncategorized'
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.name = self._format_name()
         self.type = self._parse_type()
 
@@ -60,6 +60,10 @@ class FileFormatter:
 
         return file_obj
 
+    def save_file(self, file_obj: File) -> None:
+        file_path = self.location + '.' + self.type
+        file_obj.file.save(file_path, ContentFile(self.file.read()), save=False)
+
     def size_verbose(self) -> str:
         if self.file.size < 512000:
             value = round(self.file.size / 1000, 2)
@@ -76,10 +80,6 @@ class FileFormatter:
 
         return str(value) + ext
 
-    def save_file(self, file_obj: File):
-        file_path = self.location + '.' + self.type
-        file_obj.file.save(file_path, ContentFile(self.file.read()), save=False)
-
 
 @dataclass
 class FileContentObjectFormatter(FileFormatter):
@@ -116,7 +116,7 @@ class FileUploader(ABC):
     related_field: str | None
     app_name: str = 'Uncategorized'
 
-    def null_file_obj(self, file):
+    def null_file_obj(self, file: InMemoryUploadedFile) -> File:
         formatted_file = FileFormatter(
             file=file,
             related_field=self.related_field,
@@ -135,12 +135,7 @@ class FileUploader(ABC):
 
 @dataclass
 class SingleFileUploader(FileUploader):
-    def upload(self, file: InMemoryUploadedFile) -> File:
-        file = self.null_file_obj(file)
-        file.save()
-        return file
-
-    def delete_old_files(self, content_object: FileModelMixin):
+    def delete_old_files(self, content_object: FileModelMixin) -> None:
         old_files = content_object.files.active().related_field(self.related_field)
 
         for file in old_files:
@@ -149,9 +144,14 @@ class SingleFileUploader(FileUploader):
 
         File.objects.bulk_update(old_files, ['is_active', 'is_deleted'])
 
+    def upload(self, file: InMemoryUploadedFile) -> File:
+        file = self.null_file_obj(file)
+        file.save()
+        return file
+
     def upload_from_form_field(
         self,
-        form_data,
+        form_data: dict,
         content_object: FileModelMixin
     ) -> File:
         try:

django_spire/file/mixins.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-from typing import Any
-
 from django.contrib.contenttypes.fields import GenericRelation
-
 from django.db import models
 
 from django_spire.file.models import File
@@ -13,7 +10,7 @@ from django_spire.file.tools import copy_files_from_source_to_target_model_objec
 class FileModelMixin(models.Model):
     files = GenericRelation(File, editable=False)
 
-    def copy_files_to_target_model_object(self, target: Any[models.Model]) -> File:
+    def copy_files_to_target_model_object(self, target: models.Model) -> list[File]:
         # TODO: Move to File Service
         return copy_files_from_source_to_target_model_object(source=self, target=target)
 

django_spire/file/models.py

@@ -2,9 +2,8 @@ from __future__ import annotations
 
 import json
 
-from django.contrib.contenttypes.models import ContentType
-
 from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
 
 from django_spire.file.queryset import FileQuerySet
@@ -25,10 +24,10 @@ class File(HistoryModelMixin):
 
     objects = FileQuerySet.as_manager()
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
-    def to_dict(self) -> dict[str, str]:
+    def to_dict(self) -> dict[str, str | int]:
         return {
             'name': self.name,
             'url': self.file.url,
@@ -45,4 +44,3 @@ class File(HistoryModelMixin):
         indexes = [
             models.Index(fields=['content_type', 'object_id']),
         ]
-

django_spire/file/tests/factories.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import TYPE_CHECKING
+
+from django.core.files.uploadedfile import InMemoryUploadedFile, SimpleUploadedFile
+
+from django_spire.file.models import File
+
+if TYPE_CHECKING:
+    from django.contrib.contenttypes.models import ContentType
+
+
+def create_test_file(
+    content_type: ContentType | None = None,
+    object_id: int | None = None,
+    name: str = 'test_file',
+    file_type: str = 'pdf',
+    size: str = '1.5 Mb',
+    related_field: str | None = None,
+    is_active: bool = True,
+    is_deleted: bool = False,
+) -> File:
+    file_content = b'test content'
+    uploaded_file = SimpleUploadedFile(
+        name=f'{name}.{file_type}',
+        content=file_content,
+        content_type='application/octet-stream'
+    )
+
+    return File.objects.create(
+        content_type=content_type,
+        object_id=object_id,
+        file=uploaded_file,
+        name=name,
+        type=file_type,
+        size=size,
+        related_field=related_field,
+        is_active=is_active,
+        is_deleted=is_deleted,
+    )
+
+
+def create_test_in_memory_uploaded_file(
+    name: str = 'test_file',
+    file_type: str = 'pdf',
+    content: bytes = b'test content',
+) -> InMemoryUploadedFile:
+    file_io = BytesIO(content)
+    file_io.seek(0)
+
+    return InMemoryUploadedFile(
+        file=file_io,
+        field_name='file',
+        name=f'{name}.{file_type}',
+        content_type='application/octet-stream',
+        size=len(content),
+        charset=None,
+    )

django_spire/file/tests/test_admin.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from django.contrib.admin.sites import AdminSite
+from django.contrib.contenttypes.models import ContentType
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.admin import FileAdmin
+from django_spire.file.models import File
+from django_spire.file.tests.factories import create_test_file
+from django_spire.help_desk.tests.factories import create_test_helpdesk_ticket
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileAdminTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.site = AdminSite()
+        self.admin = FileAdmin(File, self.site)
+        self.file = create_test_file()
+
+    def test_list_display(self):
+        expected = ('id', 'name', 'type', 'size', 'content_object_link', 'file_link')
+
+        assert self.admin.list_display == expected
+
+    def test_list_filter(self):
+        assert self.admin.list_filter == ('type',)
+
+    def test_search_fields(self):
+        assert self.admin.search_fields == ('id', 'name', 'type')
+
+    def test_ordering(self):
+        assert self.admin.ordering == ('-id',)
+
+    def test_content_object_link_no_related_object(self):
+        result = self.admin.content_object_link(self.file)
+
+        assert result == 'No Related Object'
+
+    def test_content_object_link_with_related_object(self):
+        ticket = create_test_helpdesk_ticket()
+        content_type = ContentType.objects.get_for_model(ticket.__class__)
+        self.file.content_type = content_type
+        self.file.object_id = ticket.pk
+        self.file.save()
+
+        result = self.admin.content_object_link(self.file)
+
+        assert 'href=' in result
+        assert str(ticket) in result
+
+    def test_file_link(self):
+        result = self.admin.file_link(self.file)
+
+        assert f'href="{self.file.file.url}"' in result
+        assert self.file.name in result
+        assert 'download' in result

django_spire/file/tests/test_apps.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.apps import FileConfig
+
+
+class FileConfigTests(BaseTestCase):
+    def test_default_auto_field(self):
+        assert FileConfig.default_auto_field == 'django.db.models.BigAutoField'
+
+    def test_label(self):
+        assert FileConfig.label == 'django_spire_file'
+
+    def test_name(self):
+        assert FileConfig.name == 'django_spire.file'
+
+    def test_required_apps(self):
+        assert FileConfig.REQUIRED_APPS == ('django_spire_core',)
+
+    def test_urlpatterns_include(self):
+        assert FileConfig.URLPATTERNS_INCLUDE == 'django_spire.file.urls'
+
+    def test_urlpatterns_namespace(self):
+        assert FileConfig.URLPATTERNS_NAMESPACE == 'file'

django_spire/file/tests/test_fields.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import json
+
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.fields import MultipleFileField, SingleFileField
+from django_spire.file.models import File
+from django_spire.file.tests.factories import create_test_file
+from django_spire.file.widgets import MultipleWidget, SingleFileWidget
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class MultipleFileFieldTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.field = MultipleFileField()
+
+    def test_widget_is_multiple_widget(self):
+        assert isinstance(self.field.widget, MultipleWidget)
+
+    def test_prepare_value_with_files(self):
+        file1 = create_test_file(name='file1')
+        file2 = create_test_file(name='file2')
+
+        result = self.field.prepare_value([file1, file2])
+        parsed = json.loads(result)
+
+        assert len(parsed) == 2
+
+    def test_prepare_value_with_none(self):
+        result = self.field.prepare_value(None)
+
+        assert result == '[]'
+
+    def test_prepare_value_with_empty_list(self):
+        result = self.field.prepare_value([])
+
+        assert result == '[]'
+
+    def test_prepare_value_contains_file_data(self):
+        file = create_test_file(name='test')
+
+        result = self.field.prepare_value([file])
+        parsed = json.loads(result)
+
+        assert parsed[0]['name'] == 'test'
+        assert 'id' in parsed[0]
+        assert 'url' in parsed[0]
+
+    def test_clean_returns_data(self):
+        data = {'test': 'value'}
+
+        result = self.field.clean(data)
+
+        assert result == data
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class SingleFileFieldTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.field = SingleFileField()
+
+    def test_widget_is_single_file_widget(self):
+        assert isinstance(self.field.widget, SingleFileWidget)
+
+    def test_prepare_value_with_file(self):
+        file = create_test_file(name='test')
+
+        result = self.field.prepare_value(file)
+        parsed = json.loads(result)
+
+        assert parsed['name'] == 'test'
+        assert 'id' in parsed
+        assert 'url' in parsed
+
+    def test_prepare_value_with_none(self):
+        result = self.field.prepare_value(None)
+
+        assert result == 'null'
+
+    def test_prepare_value_with_queryset(self):
+        file = create_test_file(name='queryset_file')
+
+        result = self.field.prepare_value(File.objects.filter(pk=file.pk))
+        parsed = json.loads(result)
+
+        assert parsed['name'] == 'queryset_file'
+
+    def test_prepare_value_with_empty_queryset(self):
+        result = self.field.prepare_value(File.objects.none())
+
+        assert result == 'null'
+
+    def test_clean_returns_data(self):
+        data = {'test': 'value'}
+
+        result = self.field.clean(data)
+
+        assert result == data

django_spire/file/tests/test_forms.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.fields import MultipleFileField
+from django_spire.file.forms import FileForm
+
+
+class FileFormTests(BaseTestCase):
+    def test_has_files_field(self):
+        assert 'files' in FileForm().fields
+
+    def test_files_field_is_multiple_file_field(self):
+        form = FileForm()
+
+        assert isinstance(form.fields['files'], MultipleFileField)
+
+    def test_form_field_count(self):
+        form = FileForm()
+
+        assert len(form.fields) == 1

django_spire/file/tests/test_interfaces.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from django.conf import settings
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.interfaces import (
+    FileFormatter,
+    MultiFileUploader,
+    SingleFileUploader,
+)
+from django_spire.file.models import File
+from django_spire.file.tests.factories import create_test_in_memory_uploaded_file
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+class FileFormatterTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.uploaded_file = create_test_in_memory_uploaded_file(
+            name='document',
+            file_type='pdf',
+            content=b'test content',
+        )
+        self.formatter = FileFormatter(file=self.uploaded_file)
+
+    def test_format_name(self):
+        assert self.formatter.name == 'document'
+
+    def test_parse_type(self):
+        assert self.formatter.type == 'pdf'
+
+    def test_location_contains_base_folder(self):
+        assert self.formatter.location.startswith(settings.BASE_FOLDER_NAME + '/')
+
+    def test_location_contains_app_name(self):
+        assert '/Uncategorized/' in self.formatter.location
+
+    def test_location_contains_file_name(self):
+        assert self.formatter.location.endswith('document')
+
+    def test_location_with_related_field(self):
+        formatter = FileFormatter(
+            file=self.uploaded_file,
+            related_field='abc',
+        )
+
+        assert '/abc/' in formatter.location
+
+    def test_location_with_custom_app_name(self):
+        formatter = FileFormatter(
+            file=self.uploaded_file,
+            app_name='CustomApp',
+        )
+
+        assert '/CustomApp/' in formatter.location
+
+    def test_size_verbose_kb(self):
+        content = b'x' * 1000
+        uploaded_file = create_test_in_memory_uploaded_file(content=content)
+        formatter = FileFormatter(file=uploaded_file)
+
+        assert 'kb' in formatter.size_verbose()
+
+    def test_size_verbose_mb(self):
+        content = b'x' * 1000000
+        uploaded_file = create_test_in_memory_uploaded_file(content=content)
+        formatter = FileFormatter(file=uploaded_file)
+
+        assert 'Mb' in formatter.size_verbose()
+
+    @override_settings(STORAGES=STORAGES_OVERRIDE)
+    def test_null_file_obj_returns_file(self):
+        result = self.formatter.null_file_obj()
+
+        assert isinstance(result, File)
+        assert result.name == 'document'
+        assert result.type == 'pdf'
+
+    @override_settings(STORAGES=STORAGES_OVERRIDE)
+    def test_null_file_obj_not_saved(self):
+        result = self.formatter.null_file_obj()
+
+        assert result.pk is None
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class SingleFileUploaderTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.uploader = SingleFileUploader(related_field='abc')
+        self.uploaded_file = create_test_in_memory_uploaded_file()
+
+    def test_upload_creates_file(self):
+        initial_count = File.objects.count()
+
+        self.uploader.upload(self.uploaded_file)
+
+        assert File.objects.count() == initial_count + 1
+
+    def test_upload_returns_file(self):
+        result = self.uploader.upload(self.uploaded_file)
+
+        assert isinstance(result, File)
+        assert result.pk is not None
+
+    def test_upload_sets_name(self):
+        result = self.uploader.upload(self.uploaded_file)
+
+        assert result.name == 'test_file'
+
+    def test_upload_sets_type(self):
+        result = self.uploader.upload(self.uploaded_file)
+
+        assert result.type == 'pdf'
+
+    def test_null_file_obj(self):
+        result = self.uploader.null_file_obj(self.uploaded_file)
+
+        assert isinstance(result, File)
+        assert result.pk is None
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class MultiFileUploaderTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.uploader = MultiFileUploader(related_field='abc')
+        self.uploaded_files = [
+            create_test_in_memory_uploaded_file(name='file1'),
+            create_test_in_memory_uploaded_file(name='file2'),
+        ]
+
+    def test_upload_creates_multiple_files(self):
+        initial_count = File.objects.count()
+
+        self.uploader.upload(self.uploaded_files)
+
+        assert File.objects.count() == initial_count + 2
+
+    def test_upload_returns_list_of_files(self):
+        result = self.uploader.upload(self.uploaded_files)
+
+        assert isinstance(result, list)
+        assert len(result) == 2
+
+    def test_upload_returns_file_instances(self):
+        result = self.uploader.upload(self.uploaded_files)
+
+        for file in result:
+            assert isinstance(file, File)
+            assert file.pk is not None
+
+    def test_upload_sets_names(self):
+        result = self.uploader.upload(self.uploaded_files)
+        names = [f.name for f in result]
+
+        assert 'file1' in names
+        assert 'file2' in names
+
+    def test_upload_empty_list(self):
+        result = self.uploader.upload([])
+
+        assert result == []
+
+    def test_null_file_obj(self):
+        uploaded_file = create_test_in_memory_uploaded_file()
+        result = self.uploader.null_file_obj(uploaded_file)
+
+        assert isinstance(result, File)
+        assert result.pk is None

django_spire/file/tests/test_models.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.tests.factories import create_test_file
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.file = create_test_file()
+
+    def test_str(self):
+        assert str(self.file) == self.file.name
+
+    def test_default_is_active(self):
+        assert self.file.is_active is True
+
+    def test_default_is_deleted(self):
+        assert self.file.is_deleted is False
+
+    def test_name_field(self):
+        assert self.file.name == 'test_file'
+
+    def test_type_field(self):
+        assert self.file.type == 'pdf'
+
+    def test_size_field(self):
+        assert self.file.size == '1.5 Mb'
+
+    def test_related_field_default(self):
+        assert self.file.related_field is None
+
+    def test_related_field_set(self):
+        file = create_test_file(related_field='abc')
+        assert file.related_field == 'abc'
+
+    def test_content_type_null(self):
+        assert self.file.content_type is None
+
+    def test_object_id_null(self):
+        assert self.file.object_id is None
+
+    def test_created_datetime_auto_set(self):
+        assert self.file.created_datetime is not None
+
+    def test_to_dict(self):
+        result = self.file.to_dict()
+
+        assert result['name'] == self.file.name
+        assert result['id'] == self.file.id
+        assert 'url' in result
+
+    def test_to_dict_keys(self):
+        result = self.file.to_dict()
+
+        assert set(result.keys()) == {'name', 'url', 'id'}
+
+    def test_to_json(self):
+        result = self.file.to_json()
+        parsed = json.loads(result)
+
+        assert parsed['name'] == self.file.name
+        assert parsed['id'] == self.file.id
+
+    def test_file_field_url(self):
+        assert self.file.file.url is not None