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

django_spire/knowledge/entry/version/block/tests/factories.py

@@ -3,11 +3,9 @@ from __future__ import annotations
 import json
 
 from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
-from django_spire.knowledge.entry.version.block.data.text_data import \
-    TextEditorBlockData
+from django_spire.knowledge.entry.version.block.data.text_data import TextEditorBlockData
 from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
-from django_spire.knowledge.entry.version.tests.factories import \
-    create_test_entry_version
+from django_spire.knowledge.entry.version.tests.factories import create_test_entry_version
 
 
 def create_test_block_form_data(**kwargs) -> dict:
@@ -18,25 +16,21 @@ def create_test_block_form_data(**kwargs) -> dict:
         'data': {'text': 'test text'},
         'tunes': {}
     }
-
     data.update(kwargs)
     return data
 
 
 def create_test_version_block(**kwargs) -> EntryVersionBlock:
     data = {
-        'version': create_test_entry_version(),
+        'version': kwargs.pop('version', None) or create_test_entry_version(),
         'order': 1,
         'type': BlockTypeChoices.TEXT,
         '_block_data': json.dumps({}),
         '_text_data': ''
     }
-
     data.update(kwargs)
     version_block = EntryVersionBlock.objects.create(**data)
-    version_block.editor_js_block_data = TextEditorBlockData(
-        text='',
-    )
+    version_block.editor_js_block_data = TextEditorBlockData(text='')
     version_block.save()
 
     return version_block

django_spire/knowledge/entry/version/block/tests/test_choices.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.list.choices import (
+    ListEditorBlockDataStyle,
+    OrderedListCounterType,
+)
+
+
+class BlockTypeChoicesTests(BaseTestCase):
+    def test_text_value(self):
+        assert BlockTypeChoices.TEXT == 'text'
+
+    def test_heading_value(self):
+        assert BlockTypeChoices.HEADING == 'heading'
+
+    def test_list_value(self):
+        assert BlockTypeChoices.LIST == 'list'
+
+    def test_choices_count(self):
+        assert len(BlockTypeChoices.choices) == 3
+
+
+class ListEditorBlockDataStyleTests(BaseTestCase):
+    def test_unordered_value(self):
+        assert ListEditorBlockDataStyle.UNORDERED == 'unordered'
+
+    def test_ordered_value(self):
+        assert ListEditorBlockDataStyle.ORDERED == 'ordered'
+
+    def test_checklist_value(self):
+        assert ListEditorBlockDataStyle.CHECKLIST == 'checklist'
+
+    def test_choices_count(self):
+        assert len(ListEditorBlockDataStyle.choices) == 3
+
+
+class OrderedListCounterTypeTests(BaseTestCase):
+    def test_numeric_value(self):
+        assert OrderedListCounterType.NUMERIC == 'numeric'
+
+    def test_upper_roman_value(self):
+        assert OrderedListCounterType.UPPER_ROMAN == 'upper-roman'
+
+    def test_lower_roman_value(self):
+        assert OrderedListCounterType.LOWER_ROMAN == 'lower-roman'
+
+    def test_upper_alpha_value(self):
+        assert OrderedListCounterType.UPPER_ALPHA == 'upper-alpha'
+
+    def test_lower_alpha_value(self):
+        assert OrderedListCounterType.LOWER_ALPHA == 'lower-alpha'
+
+    def test_choices_count(self):
+        assert len(OrderedListCounterType.choices) == 5

django_spire/knowledge/entry/version/block/tests/test_data.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.data.heading_data import HeadingEditorBlockData
+from django_spire.knowledge.entry.version.block.data.list.choices import ListEditorBlockDataStyle
+from django_spire.knowledge.entry.version.block.data.list.data import ListEditorBlockData
+from django_spire.knowledge.entry.version.block.data.text_data import TextEditorBlockData
+
+
+class TextEditorBlockDataTests(BaseTestCase):
+    def test_render_to_text(self):
+        data = TextEditorBlockData(text='Hello World')
+        result = data.render_to_text()
+        assert 'Hello World' in result
+
+    def test_render_to_text_with_html(self):
+        data = TextEditorBlockData(text='<b>Bold</b> text')
+        result = data.render_to_text()
+        assert 'Bold' in result
+
+
+class HeadingEditorBlockDataTests(BaseTestCase):
+    def test_render_to_text_h1(self):
+        data = HeadingEditorBlockData(text='Title', level=1)
+        result = data.render_to_text()
+        assert '# Title' in result
+
+    def test_render_to_text_h2(self):
+        data = HeadingEditorBlockData(text='Subtitle', level=2)
+        result = data.render_to_text()
+        assert '## Subtitle' in result
+
+    def test_render_to_text_h3(self):
+        data = HeadingEditorBlockData(text='Section', level=3)
+        result = data.render_to_text()
+        assert '### Section' in result
+
+
+class ListEditorBlockDataTests(BaseTestCase):
+    def test_render_to_text_unordered(self):
+        data = ListEditorBlockData(
+            style=ListEditorBlockDataStyle.UNORDERED,
+            items=[
+                {'content': 'Item 1', 'items': []},
+                {'content': 'Item 2', 'items': []},
+            ]
+        )
+        result = data.render_to_text()
+        assert '- Item 1' in result
+        assert '- Item 2' in result
+
+    def test_render_to_text_ordered(self):
+        data = ListEditorBlockData(
+            style=ListEditorBlockDataStyle.ORDERED,
+            meta={'start': 1},
+            items=[
+                {'content': 'First', 'items': [], 'meta': {'start': 1}},
+                {'content': 'Second', 'items': [], 'meta': {'start': 1}},
+            ]
+        )
+        result = data.render_to_text()
+        assert '1. First' in result
+
+    def test_render_to_text_checklist(self):
+        data = ListEditorBlockData(
+            style=ListEditorBlockDataStyle.CHECKLIST,
+            items=[
+                {'content': 'Done', 'items': [], 'meta': {'checked': True}},
+                {'content': 'Not done', 'items': [], 'meta': {'checked': False}},
+            ]
+        )
+        result = data.render_to_text()
+        assert '[X] Done' in result
+        assert '[ ] Not done' in result
+
+    def test_render_to_text_nested(self):
+        data = ListEditorBlockData(
+            style=ListEditorBlockDataStyle.UNORDERED,
+            items=[
+                {
+                    'content': 'Parent',
+                    'items': [
+                        {'content': 'Child', 'items': []}
+                    ]
+                },
+            ]
+        )
+        result = data.render_to_text()
+        assert 'Parent' in result
+        assert 'Child' in result

django_spire/knowledge/entry/version/block/tests/test_maps.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.heading_data import HeadingEditorBlockData
+from django_spire.knowledge.entry.version.block.data.list.data import ListEditorBlockData
+from django_spire.knowledge.entry.version.block.data.maps import (
+    EDITOR_JS_BLOCK_DATA_MAP,
+    EDITOR_JS_BLOCK_DATA_REVERSE_MAP,
+)
+from django_spire.knowledge.entry.version.block.data.text_data import TextEditorBlockData
+
+
+class EditorJsBlockDataMapTests(BaseTestCase):
+    def test_map_contains_text(self):
+        assert BlockTypeChoices.TEXT in EDITOR_JS_BLOCK_DATA_MAP
+        assert EDITOR_JS_BLOCK_DATA_MAP[BlockTypeChoices.TEXT] == TextEditorBlockData
+
+    def test_map_contains_heading(self):
+        assert BlockTypeChoices.HEADING in EDITOR_JS_BLOCK_DATA_MAP
+        assert EDITOR_JS_BLOCK_DATA_MAP[BlockTypeChoices.HEADING] == HeadingEditorBlockData
+
+    def test_map_contains_list(self):
+        assert BlockTypeChoices.LIST in EDITOR_JS_BLOCK_DATA_MAP
+        assert EDITOR_JS_BLOCK_DATA_MAP[BlockTypeChoices.LIST] == ListEditorBlockData
+
+    def test_reverse_map_contains_text(self):
+        assert TextEditorBlockData in EDITOR_JS_BLOCK_DATA_REVERSE_MAP
+        assert EDITOR_JS_BLOCK_DATA_REVERSE_MAP[TextEditorBlockData] == BlockTypeChoices.TEXT
+
+    def test_reverse_map_contains_heading(self):
+        assert HeadingEditorBlockData in EDITOR_JS_BLOCK_DATA_REVERSE_MAP
+        assert EDITOR_JS_BLOCK_DATA_REVERSE_MAP[HeadingEditorBlockData] == BlockTypeChoices.HEADING
+
+    def test_reverse_map_contains_list(self):
+        assert ListEditorBlockData in EDITOR_JS_BLOCK_DATA_REVERSE_MAP
+        assert EDITOR_JS_BLOCK_DATA_REVERSE_MAP[ListEditorBlockData] == BlockTypeChoices.LIST

django_spire/knowledge/entry/version/block/tests/test_models.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.heading_data import HeadingEditorBlockData
+from django_spire.knowledge.entry.version.block.data.list.data import ListEditorBlockData
+from django_spire.knowledge.entry.version.block.data.text_data import TextEditorBlockData
+from django_spire.knowledge.entry.version.block.tests.factories import create_test_version_block
+
+
+class EntryVersionBlockModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.version_block = create_test_version_block()
+
+    def test_editor_js_block_data_getter_text(self):
+        self.version_block.type = BlockTypeChoices.TEXT
+        self.version_block._block_data = {'text': 'Hello'}
+        result = self.version_block.editor_js_block_data
+        assert isinstance(result, TextEditorBlockData)
+        assert result.text == 'Hello'
+
+    def test_editor_js_block_data_getter_heading(self):
+        self.version_block.type = BlockTypeChoices.HEADING
+        self.version_block._block_data = {'text': 'Title', 'level': 1}
+        result = self.version_block.editor_js_block_data
+        assert isinstance(result, HeadingEditorBlockData)
+        assert result.text == 'Title'
+        assert result.level == 1
+
+    def test_editor_js_block_data_getter_list(self):
+        self.version_block.type = BlockTypeChoices.LIST
+        self.version_block._block_data = {
+            'style': 'unordered',
+            'items': [{'content': 'Item 1', 'items': []}]
+        }
+        result = self.version_block.editor_js_block_data
+        assert isinstance(result, ListEditorBlockData)
+
+    def test_editor_js_block_data_setter(self):
+        text_data = TextEditorBlockData(text='New text')
+        self.version_block.editor_js_block_data = text_data
+        assert self.version_block._block_data == {'text': 'New text'}
+        assert 'New text' in self.version_block._text_data
+
+    def test_update_editor_js_block_data_from_dict(self):
+        self.version_block.type = BlockTypeChoices.TEXT
+        self.version_block.update_editor_js_block_data_from_dict({'text': 'Updated'})
+        assert self.version_block._block_data == {'text': 'Updated'}
+
+    def test_render_to_text(self):
+        self.version_block.type = BlockTypeChoices.TEXT
+        self.version_block._block_data = {'text': 'Hello World'}
+        result = self.version_block.render_to_text()
+        assert 'Hello World' in result

django_spire/knowledge/entry/version/block/tests/test_querysets.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+from django_spire.knowledge.entry.version.block.tests.factories import create_test_version_block
+from django_spire.knowledge.entry.version.tests.factories import create_test_entry_version
+
+
+class EntryVersionBlockQuerySetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.entry_version = create_test_entry_version()
+        self.block1 = create_test_version_block(version=self.entry_version, order=0)
+        self.block2 = create_test_version_block(version=self.entry_version, order=1)
+
+    def test_format_for_editor(self):
+        result = list(
+            EntryVersionBlock.objects
+            .filter(version=self.entry_version)
+            .format_for_editor()
+        )
+        assert len(result) == 2
+        assert 'id' in result[0]
+        assert 'type' in result[0]
+        assert 'data' in result[0]
+        assert 'tunes' in result[0]
+
+    def test_format_for_editor_ordering(self):
+        result = list(
+            EntryVersionBlock.objects
+            .filter(version=self.entry_version)
+            .format_for_editor()
+        )
+        assert result[0]['id'] == self.block1.id
+        assert result[1]['id'] == self.block2.id

django_spire/knowledge/entry/version/block/tests/test_services.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+from django_spire.knowledge.entry.version.tests.factories import create_test_entry_version
+
+
+class EntryVersionBlockFactoryServiceTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.entry_version = create_test_entry_version()
+
+    def test_create_validated_block_text(self):
+        block = EntryVersionBlock.services.factory.create_validated_block(
+            entry_version=self.entry_version,
+            type=BlockTypeChoices.TEXT,
+            data={'text': 'Test content'},
+            order=0
+        )
+        assert block.type == BlockTypeChoices.TEXT
+        assert block.order == 0
+        assert block._block_data == {'text': 'Test content'}
+
+    def test_create_validated_block_heading(self):
+        block = EntryVersionBlock.services.factory.create_validated_block(
+            entry_version=self.entry_version,
+            type=BlockTypeChoices.HEADING,
+            data={'text': 'Title', 'level': 1},
+            order=0
+        )
+        assert block.type == BlockTypeChoices.HEADING
+        assert block._block_data['level'] == 1
+
+    def test_create_validated_block_list(self):
+        block = EntryVersionBlock.services.factory.create_validated_block(
+            entry_version=self.entry_version,
+            type=BlockTypeChoices.LIST,
+            data={
+                'style': 'unordered',
+                'items': [{'content': 'Item', 'items': []}]
+            },
+            order=0
+        )
+        assert block.type == BlockTypeChoices.LIST
+
+    def test_create_validated_block_with_tunes(self):
+        tunes = {'alignment': 'center'}
+        block = EntryVersionBlock.services.factory.create_validated_block(
+            entry_version=self.entry_version,
+            type=BlockTypeChoices.TEXT,
+            data={'text': 'Centered'},
+            order=0,
+            tunes=tunes
+        )
+        assert block.tunes == tunes
+
+    def test_create_validated_block_sets_version(self):
+        block = EntryVersionBlock.services.factory.create_validated_block(
+            entry_version=self.entry_version,
+            type=BlockTypeChoices.TEXT,
+            data={'text': 'Test'},
+            order=0
+        )
+        assert block.version == self.entry_version

django_spire/knowledge/entry/version/choices.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.db.models import TextChoices
 
 

django_spire/knowledge/entry/version/converters/converter.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 
 if TYPE_CHECKING:

django_spire/knowledge/entry/version/converters/docx_converter.py

@@ -7,16 +7,13 @@ from typing import TYPE_CHECKING
 from markitdown import MarkItDown
 
 from django_spire.knowledge.entry.version.consts import MARKDOWN_AI_CHUNK_SIZE
-from django_spire.knowledge.entry.version.converters.converter import \
-    BaseConverter
-from django_spire.knowledge.entry.version.block import models
-from django_spire.knowledge.entry.version.converters.markdown_converter import \
-    MarkdownConverter
-from django_spire.knowledge.entry.version.intelligence.bots.markdown_format_llm_bot import \
-    MarkdownFormatLlmBot
+from django_spire.knowledge.entry.version.converters.converter import BaseConverter
+from django_spire.knowledge.entry.version.converters.markdown_converter import MarkdownConverter
+from django_spire.knowledge.entry.version.intelligence.bots.markdown_format_llm_bot import MarkdownFormatLlmBot
 
 if TYPE_CHECKING:
     from django_spire.file.models import File
+    from django_spire.knowledge.entry.version.block import models
 
 
 class DocxConverter(BaseConverter):

django_spire/knowledge/entry/version/converters/markdown_converter.py

@@ -1,25 +1,24 @@
 from __future__ import annotations
 
 import logging
+import marko
 import re
+
 from collections import defaultdict
 from typing import TYPE_CHECKING
 
-import marko
 from bs4 import BeautifulSoup
 from django.core.files.storage import default_storage
 from markitdown.converters import HtmlConverter
 from marko.block import Heading, List, ListItem, Paragraph, BlankLine
-from marko.element import Element
 
 from django_spire.knowledge.entry.version.block import models
 from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
-from django_spire.knowledge.entry.version.block.data.list.choices import \
-    ListEditorBlockDataStyle
-from django_spire.knowledge.entry.version.converters.converter import \
-    BaseConverter
+from django_spire.knowledge.entry.version.block.data.list.choices import ListEditorBlockDataStyle
+from django_spire.knowledge.entry.version.converters.converter import BaseConverter
 
 if TYPE_CHECKING:
+    from marko.element import Element
     from django_spire.knowledge.entry.version.models import EntryVersion
     from django_spire.file.models import File
     from marko.block import BlockElement
@@ -54,8 +53,8 @@ class MarkdownConverter(BaseConverter):
             return self.convert_markdown_to_blocks(f.read())
 
     def convert_markdown_to_blocks(
-            self,
-            markdown_content: str
+        self,
+        markdown_content: str
     ) -> list[models.EntryVersionBlock]:
         marko_blocks = marko.parse(markdown_content).children
 
@@ -124,9 +123,9 @@ class MarkdownConverter(BaseConverter):
 
     @classmethod
     def _marko_list_item_block_to_editor_block_data_dict(
-            cls,
-            marko_list_item_block: ListItem,
-            parent_marko_list_block: List | None = None,
+        cls,
+        marko_list_item_block: ListItem,
+        parent_marko_list_block: List | None = None
     ):
         list_item_editor_block_data_kwargs = {
             'items': [],
@@ -165,6 +164,7 @@ class MarkdownConverter(BaseConverter):
         list_item_editor_block_data_kwargs['content'] = content
 
         list_editor_block_data_style = None
+
         if parent_marko_list_block:
             # We determine the entire list style from the top level list items for simplicity.
             # If parent_marko_list_block is present, it means we are processing the top level list.
@@ -182,17 +182,17 @@ class MarkdownConverter(BaseConverter):
         if isinstance(marko_block, BlankLine):
             return { 'text': '' }
 
-        elif isinstance(marko_block, Paragraph):
+        if isinstance(marko_block, Paragraph):
             editor_block_text_string = cls._remove_outer_html_tags(marko.render(marko_block))
             return { 'text': editor_block_text_string }
 
-        elif isinstance(marko_block, Heading):
+        if isinstance(marko_block, Heading):
             return {
                 'text': cls._remove_outer_html_tags(marko.render(marko_block)),
                 'level': marko_block.level,
             }
 
-        elif isinstance(marko_block, List):
+        if isinstance(marko_block, List):
             list_editor_block_data_dict = {
                 'items': [],
                 'style': ListEditorBlockDataStyle.UNORDERED,
@@ -208,12 +208,12 @@ class MarkdownConverter(BaseConverter):
 
             return list_editor_block_data_dict
 
-        else:
-            logging.warning(
-                f'Unsupported marko block type: {marko_block.__class__.__name__!r}. '
-                f'Rendering content to html and adding to markdown as a basic paragraph block.'
-            )
-            return { 'text': marko.render(marko_block) }
+        logging.warning(
+            f'Unsupported marko block type: {marko_block.__class__.__name__!r}. '
+            f'Rendering content to html and adding to markdown as a basic paragraph block.'
+        )
+
+        return { 'text': marko.render(marko_block) }
 
 
     @classmethod

django_spire/knowledge/entry/version/maps.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from django_spire.knowledge.entry.version.converters.docx_converter import \
-    DocxConverter
-from django_spire.knowledge.entry.version.converters.markdown_converter import \
-    MarkdownConverter
+from django_spire.knowledge.entry.version.converters.docx_converter import DocxConverter
+from django_spire.knowledge.entry.version.converters.markdown_converter import MarkdownConverter
+
 
 FILE_TYPE_CONVERTER_MAP = {
     'md': MarkdownConverter,
     'docx': DocxConverter
-}
+}

django_spire/knowledge/entry/version/querysets.py

@@ -14,4 +14,4 @@ class EntryVersionQuerySet(HistoryQuerySet):
                 'blocks',
                 queryset=EntryVersionBlock.objects.order_by('order')
             )
-        )
+        )

django_spire/knowledge/entry/version/seeding/seeder.py

@@ -11,8 +11,7 @@ from django_spire.knowledge.entry.models import Entry
 from django_spire.knowledge.entry.version import models
 
 from django_spire.contrib.seeding import DjangoModelSeeder
-from django_spire.knowledge.entry.version.block.data.maps import \
-    EDITOR_JS_BLOCK_DATA_REVERSE_MAP
+from django_spire.knowledge.entry.version.block.data.maps import EDITOR_JS_BLOCK_DATA_REVERSE_MAP
 from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
 from django_spire.knowledge.entry.version.block.seeding.constants import SAFETY_BLOCKS
 from django_spire.knowledge.entry.version.choices import EntryVersionStatusChoices

django_spire/knowledge/entry/version/services/processor_service.py

@@ -25,7 +25,6 @@ class EntryVersionProcessorService(BaseDjangoModelService['EntryVersion']):
 
         entry_blocks_to_add = []
         entry_blocks_to_update = []
-        entry_blocks_to_delete = []
 
         handled_block_ids = []
 
@@ -54,9 +53,11 @@ class EntryVersionProcessorService(BaseDjangoModelService['EntryVersion']):
 
                 handled_block_ids.append(block_data['id'])
 
-        for entry_block in old_entry_blocks:
-            if entry_block.id not in handled_block_ids:
-                entry_blocks_to_delete.append(entry_block.id)
+        entry_blocks_to_delete = [
+            entry_block.id
+            for entry_block in old_entry_blocks
+            if entry_block.id not in handled_block_ids
+        ]
 
         with transaction.atomic():
             EntryVersionBlock.objects.filter(id__in=entry_blocks_to_delete).delete()

django_spire/knowledge/entry/version/services/service.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from django_spire.contrib.service import BaseDjangoModelService
-from django_spire.knowledge.entry.version.services.processor_service import \
-    EntryVersionProcessorService
+from django_spire.knowledge.entry.version.services.processor_service import EntryVersionProcessorService
 
 if TYPE_CHECKING:
     from django_spire.knowledge.entry.version.models import EntryVersion

django_spire/knowledge/entry/version/tests/factories.py

@@ -9,8 +9,8 @@ from django_spire.knowledge.entry.version.models import EntryVersion
 
 def create_test_entry_version(**kwargs) -> EntryVersion:
     data = {
-        'entry': create_test_entry(),
-        'author': create_user(username=random_string(k=10)),
+        'entry': kwargs.pop('entry', None) or create_test_entry(),
+        'author': kwargs.pop('author', None) or create_user(username=random_string(k=10)),
         'is_deleted': False,
         'is_active': True
     }

django_spire/knowledge/entry/version/tests/test_choices.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.entry.version.choices import EntryVersionStatusChoices
+
+
+class EntryVersionStatusChoicesTests(BaseTestCase):
+    def test_draft_value(self):
+        assert EntryVersionStatusChoices.DRAFT == 'draft'
+
+    def test_published_value(self):
+        assert EntryVersionStatusChoices.PUBLISHED == 'published'
+
+    def test_archived_value(self):
+        assert EntryVersionStatusChoices.ARCHIVED == 'archived'
+
+    def test_choices_count(self):
+        assert len(EntryVersionStatusChoices.choices) == 3