Removed "Ändern" and "Löschen"-Links

- Add 41 comprehensive test cases covering all functionality
- Test AbschnittTyp model creation and validation
- Test Textabschnitt abstract model through VorgabeLangtext
- Test all rendering types: text, lists, tables, code, diagrams
- Test markdown rendering with footnotes and formatting
- Test table conversion from markdown to Bootstrap HTML
- Test diagram caching with mocked external service calls
- Test diagram error handling and custom options
- Test clear_diagram_cache management command
- Test integration with dokumente models
- All tests passing (41/41)

abschnitte/tests.py

@@ -1,3 +1,820 @@
-from django.test import TestCase
+from django.test import TestCase, TransactionTestCase
+from django.core.management import call_command
+from django.conf import settings
+from django.core.files.storage import default_storage
+from unittest.mock import patch, Mock, MagicMock
+from io import StringIO
+import os
+import hashlib
+import tempfile
+import shutil
 
-# Create your tests here.
+from .models import AbschnittTyp, Textabschnitt
+from .utils import render_textabschnitte, md_table_to_html
+from diagramm_proxy.diagram_cache import (
+    get_cached_diagram, compute_hash, get_cache_path, clear_cache
+)
+
+
+class AbschnittTypModelTest(TestCase):
+    """Test cases for AbschnittTyp model"""
+
+    def setUp(self):
+        """Set up test data"""
+        self.abschnitttyp = AbschnittTyp.objects.create(
+            abschnitttyp="text"
+        )
+
+    def test_abschnitttyp_creation(self):
+        """Test that AbschnittTyp is created correctly"""
+        self.assertEqual(self.abschnitttyp.abschnitttyp, "text")
+
+    def test_abschnitttyp_str(self):
+        """Test string representation of AbschnittTyp"""
+        self.assertEqual(str(self.abschnitttyp), "text")
+
+    def test_abschnitttyp_verbose_name_plural(self):
+        """Test verbose name plural"""
+        self.assertEqual(
+            AbschnittTyp._meta.verbose_name_plural,
+            "Abschnitttypen"
+        )
+
+    def test_abschnitttyp_primary_key(self):
+        """Test that abschnitttyp field is the primary key"""
+        pk_field = AbschnittTyp._meta.pk
+        self.assertEqual(pk_field.name, 'abschnitttyp')
+
+    def test_create_multiple_abschnitttypen(self):
+        """Test creating multiple AbschnittTyp objects"""
+        types = ['liste ungeordnet', 'liste geordnet', 'tabelle', 'diagramm', 'code']
+        for typ in types:
+            AbschnittTyp.objects.create(abschnitttyp=typ)
+
+        self.assertEqual(AbschnittTyp.objects.count(), 6)  # Including setUp type
+
+
+class TextabschnittModelTest(TestCase):
+    """Test cases for Textabschnitt abstract model using VorgabeLangtext"""
+
+    def setUp(self):
+        """Set up test data"""
+        from dokumente.models import Dokumententyp, Dokument, Vorgabe, VorgabeLangtext, Thema
+        from datetime import date
+
+        self.typ_text = AbschnittTyp.objects.create(abschnitttyp="text")
+        self.typ_code = AbschnittTyp.objects.create(abschnitttyp="code")
+
+        # Create required dokumente objects
+        self.dokumententyp = Dokumententyp.objects.create(
+            name="Test Type", verantwortliche_ve="TEST"
+        )
+        self.dokument = Dokument.objects.create(
+            nummer="TEST-001",
+            name="Test Doc",
+            dokumententyp=self.dokumententyp,
+            aktiv=True
+        )
+        self.thema = Thema.objects.create(name="Test Thema")
+        self.vorgabe = Vorgabe.objects.create(
+            dokument=self.dokument,
+            nummer=1,
+            order=1,
+            thema=self.thema,
+            titel="Test Vorgabe",
+            gueltigkeit_von=date.today()
+        )
+
+    def test_textabschnitt_creation(self):
+        """Test that Textabschnitt can be instantiated via concrete model"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="Test content",
+            order=1
+        )
+        self.assertEqual(abschnitt.abschnitttyp, self.typ_text)
+        self.assertEqual(abschnitt.inhalt, "Test content")
+        self.assertEqual(abschnitt.order, 1)
+
+    def test_textabschnitt_default_order(self):
+        """Test that order defaults to 0"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="Test"
+        )
+        self.assertEqual(abschnitt.order, 0)
+
+    def test_textabschnitt_blank_fields(self):
+        """Test that abschnitttyp and inhalt can be blank/null"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe
+        )
+        self.assertIsNone(abschnitt.abschnitttyp)
+        self.assertIsNone(abschnitt.inhalt)
+
+    def test_textabschnitt_ordering(self):
+        """Test that Textabschnitte can be ordered"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt1 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="First",
+            order=2
+        )
+        abschnitt2 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="Second",
+            order=1
+        )
+        abschnitt3 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="Third",
+            order=3
+        )
+
+        ordered = VorgabeLangtext.objects.filter(abschnitt=self.vorgabe).order_by('order')
+        self.assertEqual(list(ordered), [abschnitt2, abschnitt1, abschnitt3])
+
+    def test_textabschnitt_foreign_key_protection(self):
+        """Test that AbschnittTyp is protected from deletion"""
+        from dokumente.models import VorgabeLangtext
+        from django.db.models import ProtectedError
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="Test"
+        )
+
+        # Try to delete the AbschnittTyp
+        with self.assertRaises(ProtectedError):
+            self.typ_text.delete()
+
+
+class RenderTextabschnitteTest(TestCase):
+    """Test cases for render_textabschnitte function"""
+
+    def setUp(self):
+        """Set up test data"""
+        from dokumente.models import Dokumententyp, Dokument, Vorgabe, VorgabeLangtext, Thema
+        from datetime import date
+
+        self.typ_text = AbschnittTyp.objects.create(abschnitttyp="text")
+        self.typ_unordered = AbschnittTyp.objects.create(abschnitttyp="liste ungeordnet")
+        self.typ_ordered = AbschnittTyp.objects.create(abschnitttyp="liste geordnet")
+        self.typ_table = AbschnittTyp.objects.create(abschnitttyp="tabelle")
+        self.typ_code = AbschnittTyp.objects.create(abschnitttyp="code")
+        self.typ_diagram = AbschnittTyp.objects.create(abschnitttyp="diagramm")
+
+        # Create required dokumente objects
+        self.dokumententyp = Dokumententyp.objects.create(
+            name="Test Type", verantwortliche_ve="TEST"
+        )
+        self.dokument = Dokument.objects.create(
+            nummer="TEST-001",
+            name="Test Doc",
+            dokumententyp=self.dokumententyp,
+            aktiv=True
+        )
+        self.thema = Thema.objects.create(name="Test Thema")
+        self.vorgabe = Vorgabe.objects.create(
+            dokument=self.dokument,
+            nummer=1,
+            order=1,
+            thema=self.thema,
+            titel="Test Vorgabe",
+            gueltigkeit_von=date.today()
+        )
+
+    def test_render_empty_queryset(self):
+        """Test rendering an empty queryset"""
+        from dokumente.models import VorgabeLangtext
+
+        result = render_textabschnitte(VorgabeLangtext.objects.none())
+        self.assertEqual(result, [])
+
+    def test_render_text_markdown(self):
+        """Test rendering plain text with markdown"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="# Heading\n\nThis is **bold** text.",
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        self.assertEqual(len(result), 1)
+        typ, html = result[0]
+        self.assertEqual(typ, "text")
+        self.assertIn("<h1>Heading</h1>", html)
+        self.assertIn("<strong>bold</strong>", html)
+
+    def test_render_text_with_footnotes(self):
+        """Test rendering text with footnotes"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="This is text[^1].\n\n[^1]: This is a footnote.",
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertIn("footnote", html.lower())
+
+    def test_render_unordered_list(self):
+        """Test rendering unordered list"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_unordered,
+            inhalt="Item 1\nItem 2\nItem 3",
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, "liste ungeordnet")
+        self.assertIn("<ul>", html)
+        self.assertIn("<li>Item 1</li>", html)
+        self.assertIn("<li>Item 2</li>", html)
+        self.assertIn("<li>Item 3</li>", html)
+
+    def test_render_ordered_list(self):
+        """Test rendering ordered list"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_ordered,
+            inhalt="First item\nSecond item\nThird item",
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, "liste geordnet")
+        self.assertIn("<ol>", html)
+        self.assertIn("<li>First item</li>", html)
+        self.assertIn("<li>Second item</li>", html)
+        self.assertIn("<li>Third item</li>", html)
+
+    def test_render_table(self):
+        """Test rendering table"""
+        from dokumente.models import VorgabeLangtext
+
+        table_content = """| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+| Cell 3   | Cell 4   |"""
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_table,
+            inhalt=table_content,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, "tabelle")
+        self.assertIn('<table class="table table-bordered table-hover">', html)
+        self.assertIn("<thead>", html)
+        self.assertIn("<th>Header 1</th>", html)
+        self.assertIn("<th>Header 2</th>", html)
+        self.assertIn("<tbody>", html)
+        self.assertIn("<td>Cell 1</td>", html)
+        self.assertIn("<td>Cell 2</td>", html)
+
+    def test_render_code_block(self):
+        """Test rendering code block"""
+        from dokumente.models import VorgabeLangtext
+
+        code_content = "def hello():\n    print('Hello, World!')"
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_code,
+            inhalt=code_content,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, "code")
+        self.assertIn("<pre><code>", html)
+        self.assertIn("</code></pre>", html)
+        self.assertIn("hello", html)
+
+    @patch('abschnitte.utils.get_cached_diagram')
+    def test_render_diagram_success(self, mock_get_cached):
+        """Test rendering diagram with successful caching"""
+        from dokumente.models import VorgabeLangtext
+
+        mock_get_cached.return_value = "diagram_cache/plantuml/abc123.svg"
+
+        diagram_content = """plantuml
+@startuml
+Alice -> Bob: Hello
+@enduml"""
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_diagram,
+            inhalt=diagram_content,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, "diagramm")
+        self.assertIn('<img', html)
+        self.assertIn('width="100%"', html)
+        self.assertIn('diagram_cache/plantuml/abc123.svg', html)
+
+        # Verify get_cached_diagram was called correctly
+        mock_get_cached.assert_called_once()
+        args = mock_get_cached.call_args[0]
+        self.assertEqual(args[0], "plantuml")
+        self.assertIn("Alice -> Bob", args[1])
+
+    @patch('abschnitte.utils.get_cached_diagram')
+    def test_render_diagram_with_options(self, mock_get_cached):
+        """Test rendering diagram with custom options"""
+        from dokumente.models import VorgabeLangtext
+
+        mock_get_cached.return_value = "diagram_cache/mermaid/xyz789.svg"
+
+        diagram_content = """mermaid
+option: width="50%" height="300px"
+graph TD
+    A-->B"""
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_diagram,
+            inhalt=diagram_content,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertIn('width="50%"', html)
+        self.assertIn('height="300px"', html)
+
+    @patch('abschnitte.utils.get_cached_diagram')
+    def test_render_diagram_error(self, mock_get_cached):
+        """Test rendering diagram when caching fails"""
+        from dokumente.models import VorgabeLangtext
+
+        mock_get_cached.side_effect = Exception("Connection error")
+
+        diagram_content = """plantuml
+@startuml
+A -> B
+@enduml"""
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_diagram,
+            inhalt=diagram_content,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertIn("Error generating diagram", html)
+        self.assertIn("Connection error", html)
+        self.assertIn('class="text-danger"', html)
+
+    def test_render_multiple_abschnitte(self):
+        """Test rendering multiple Textabschnitte in order"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt1 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="First section",
+            order=1
+        )
+        abschnitt2 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_unordered,
+            inhalt="Item 1\nItem 2",
+            order=2
+        )
+        abschnitt3 = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_code,
+            inhalt="print('hello')",
+            order=3
+        )
+
+        result = render_textabschnitte(
+            VorgabeLangtext.objects.filter(abschnitt=self.vorgabe).order_by('order')
+        )
+
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result[0][0], "text")
+        self.assertEqual(result[1][0], "liste ungeordnet")
+        self.assertEqual(result[2][0], "code")
+
+    def test_render_abschnitt_without_type(self):
+        """Test rendering Textabschnitt without AbschnittTyp"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=None,
+            inhalt="Content without type",
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        typ, html = result[0]
+        self.assertEqual(typ, '')
+        self.assertIn("Content without type", html)
+
+    def test_render_abschnitt_with_empty_content(self):
+        """Test rendering Textabschnitt with empty content"""
+        from dokumente.models import VorgabeLangtext
+
+        abschnitt = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt=None,
+            order=1
+        )
+
+        result = render_textabschnitte(VorgabeLangtext.objects.filter(abschnitt=self.vorgabe))
+        self.assertEqual(len(result), 1)
+        typ, html = result[0]
+        self.assertEqual(typ, "text")
+
+
+class MdTableToHtmlTest(TestCase):
+    """Test cases for md_table_to_html function"""
+
+    def test_simple_table(self):
+        """Test converting a simple markdown table to HTML"""
+        md = """| Name | Age |
+|------|-----|
+| John | 30  |
+| Jane | 25  |"""
+
+        html = md_table_to_html(md)
+
+        self.assertIn('<table class="table table-bordered table-hover">', html)
+        self.assertIn("<thead>", html)
+        self.assertIn("<th>Name</th>", html)
+        self.assertIn("<th>Age</th>", html)
+        self.assertIn("<tbody>", html)
+        self.assertIn("<td>John</td>", html)
+        self.assertIn("<td>30</td>", html)
+        self.assertIn("<td>Jane</td>", html)
+        self.assertIn("<td>25</td>", html)
+
+    def test_table_with_multiple_rows(self):
+        """Test table with multiple rows"""
+        md = """| A | B | C |
+|---|---|---|
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |
+| 7 | 8 | 9 |"""
+
+        html = md_table_to_html(md)
+
+        self.assertEqual(html.count("<tr>"), 4)  # 1 header + 3 body rows
+        self.assertEqual(html.count("<td>"), 9)  # 3x3 cells
+        self.assertEqual(html.count("<th>"), 3)  # 3 headers
+
+    def test_table_with_spaces(self):
+        """Test table with extra spaces"""
+        md = """  |  Header 1  |  Header 2  |
+  | --------- | ---------- |
+  |  Value 1  |  Value 2   |  """
+
+        html = md_table_to_html(md)
+
+        self.assertIn("<th>Header 1</th>", html)
+        self.assertIn("<th>Header 2</th>", html)
+        self.assertIn("<td>Value 1</td>", html)
+        self.assertIn("<td>Value 2</td>", html)
+
+    def test_table_with_empty_cells(self):
+        """Test table with empty cells"""
+        md = """| Col1 | Col2 | Col3 |
+|------|------|------|
+| A    |      | C    |
+|      | B    |      |"""
+
+        html = md_table_to_html(md)
+
+        self.assertIn("<td>A</td>", html)
+        self.assertIn("<td></td>", html)
+        self.assertIn("<td>C</td>", html)
+        self.assertIn("<td>B</td>", html)
+
+    def test_table_insufficient_lines(self):
+        """Test that ValueError is raised for insufficient lines"""
+        md = """| Header |"""
+
+        with self.assertRaises(ValueError) as context:
+            md_table_to_html(md)
+
+        self.assertIn("at least header + separator", str(context.exception))
+
+    def test_table_empty_string(self):
+        """Test that ValueError is raised for empty string"""
+        with self.assertRaises(ValueError):
+            md_table_to_html("")
+
+    def test_table_only_whitespace(self):
+        """Test that ValueError is raised for only whitespace"""
+        with self.assertRaises(ValueError):
+            md_table_to_html("   \n   \n   ")
+
+
+class DiagramCacheTest(TestCase):
+    """Test cases for diagram caching functionality"""
+
+    def setUp(self):
+        """Set up test environment"""
+        # Create a temporary directory for testing
+        self.test_media_root = tempfile.mkdtemp()
+        self.original_media_root = settings.MEDIA_ROOT
+        settings.MEDIA_ROOT = self.test_media_root
+
+    def tearDown(self):
+        """Clean up test environment"""
+        # Restore original settings
+        settings.MEDIA_ROOT = self.original_media_root
+        # Remove test directory
+        if os.path.exists(self.test_media_root):
+            shutil.rmtree(self.test_media_root)
+
+    def test_compute_hash(self):
+        """Test that compute_hash generates consistent SHA256 hashes"""
+        content1 = "test content"
+        content2 = "test content"
+        content3 = "different content"
+
+        hash1 = compute_hash(content1)
+        hash2 = compute_hash(content2)
+        hash3 = compute_hash(content3)
+
+        # Same content should produce same hash
+        self.assertEqual(hash1, hash2)
+        # Different content should produce different hash
+        self.assertNotEqual(hash1, hash3)
+        # Hash should be 64 characters (SHA256 hex)
+        self.assertEqual(len(hash1), 64)
+
+    def test_get_cache_path(self):
+        """Test that get_cache_path generates correct paths"""
+        diagram_type = "plantuml"
+        content_hash = "abc123"
+
+        path = get_cache_path(diagram_type, content_hash)
+
+        self.assertIn("diagram_cache", path)
+        self.assertIn("plantuml", path)
+        self.assertIn("abc123.svg", path)
+
+    @patch('diagramm_proxy.diagram_cache.requests.post')
+    @patch('diagramm_proxy.diagram_cache.default_storage')
+    def test_get_cached_diagram_miss(self, mock_storage, mock_post):
+        """Test diagram generation on cache miss"""
+        # Setup mocks
+        mock_storage.exists.return_value = False
+        mock_storage.path.return_value = os.path.join(
+            self.test_media_root, 'diagram_cache/plantuml/test.svg'
+        )
+        mock_response = Mock()
+        mock_response.content = b'<svg>test</svg>'
+        mock_post.return_value = mock_response
+
+        diagram_content = "@startuml\nA -> B\n@enduml"
+
+        # Call function
+        result = get_cached_diagram("plantuml", diagram_content)
+
+        # Verify POST request was made
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
+        # Check URL in positional args (first argument)
+        self.assertIn("plantuml/svg", call_args[0][0])
+
+        # Verify storage.save was called
+        mock_storage.save.assert_called_once()
+
+    @patch('diagramm_proxy.diagram_cache.default_storage')
+    def test_get_cached_diagram_hit(self, mock_storage):
+        """Test diagram retrieval on cache hit"""
+        # Setup mock - diagram exists in cache
+        mock_storage.exists.return_value = True
+
+        diagram_content = "@startuml\nA -> B\n@enduml"
+
+        # Call function
+        result = get_cached_diagram("plantuml", diagram_content)
+
+        # Verify no save was attempted (cache hit)
+        mock_storage.save.assert_not_called()
+
+        # Verify result contains expected path elements
+        self.assertIn("diagram_cache", result)
+        self.assertIn("plantuml", result)
+        self.assertIn(".svg", result)
+
+    @patch('diagramm_proxy.diagram_cache.requests.post')
+    @patch('diagramm_proxy.diagram_cache.default_storage')
+    def test_get_cached_diagram_request_error(self, mock_storage, mock_post):
+        """Test that request errors are properly raised"""
+        import requests
+
+        mock_storage.exists.return_value = False
+        mock_storage.path.return_value = os.path.join(
+            self.test_media_root, 'diagram_cache/plantuml/test.svg'
+        )
+        mock_post.side_effect = requests.RequestException("Connection error")
+
+        with self.assertRaises(requests.RequestException):
+            get_cached_diagram("plantuml", "@startuml\nA -> B\n@enduml")
+
+    @patch('diagramm_proxy.diagram_cache.default_storage')
+    def test_clear_cache_specific_type(self, mock_storage):
+        """Test clearing cache for specific diagram type"""
+        # Create real test cache structure for this test
+        cache_dir = os.path.join(self.test_media_root, 'diagram_cache', 'plantuml')
+        os.makedirs(cache_dir, exist_ok=True)
+
+        # Create test files
+        test_file1 = os.path.join(cache_dir, 'test1.svg')
+        test_file2 = os.path.join(cache_dir, 'test2.svg')
+        open(test_file1, 'w').close()
+        open(test_file2, 'w').close()
+
+        # Mock storage methods
+        mock_storage.exists.return_value = True
+        mock_storage.path.return_value = cache_dir
+
+        # Clear cache
+        clear_cache('plantuml')
+
+        # Verify files are deleted
+        self.assertFalse(os.path.exists(test_file1))
+        self.assertFalse(os.path.exists(test_file2))
+
+    @patch('diagramm_proxy.diagram_cache.default_storage')
+    def test_clear_cache_all_types(self, mock_storage):
+        """Test clearing cache for all diagram types"""
+        # Create real test cache structure with multiple types
+        cache_root = os.path.join(self.test_media_root, 'diagram_cache')
+        for diagram_type in ['plantuml', 'mermaid', 'graphviz']:
+            cache_dir = os.path.join(cache_root, diagram_type)
+            os.makedirs(cache_dir, exist_ok=True)
+            test_file = os.path.join(cache_dir, 'test.svg')
+            open(test_file, 'w').close()
+
+        # Mock storage methods
+        mock_storage.exists.return_value = True
+        mock_storage.path.return_value = cache_root
+
+        # Clear all cache
+        clear_cache()
+
+        # Verify all files are deleted
+        for diagram_type in ['plantuml', 'mermaid', 'graphviz']:
+            test_file = os.path.join(cache_root, diagram_type, 'test.svg')
+            self.assertFalse(os.path.exists(test_file))
+
+
+class ClearDiagramCacheCommandTest(TestCase):
+    """Test cases for clear_diagram_cache management command"""
+
+    def setUp(self):
+        """Set up test environment"""
+        self.test_media_root = tempfile.mkdtemp()
+        self.original_media_root = settings.MEDIA_ROOT
+        settings.MEDIA_ROOT = self.test_media_root
+
+    def tearDown(self):
+        """Clean up test environment"""
+        settings.MEDIA_ROOT = self.original_media_root
+        if os.path.exists(self.test_media_root):
+            shutil.rmtree(self.test_media_root)
+
+    def test_command_without_type(self):
+        """Test running command without specifying type"""
+        # Create test cache
+        cache_dir = os.path.join(self.test_media_root, 'diagram_cache', 'plantuml')
+        os.makedirs(cache_dir, exist_ok=True)
+        test_file = os.path.join(cache_dir, 'test.svg')
+        open(test_file, 'w').close()
+
+        # Run command
+        out = StringIO()
+        call_command('clear_diagram_cache', stdout=out)
+
+        # Check output
+        self.assertIn('Clearing all diagram caches', out.getvalue())
+        self.assertIn('Cache cleared successfully', out.getvalue())
+
+    def test_command_with_type(self):
+        """Test running command with specific diagram type"""
+        # Create test cache
+        cache_dir = os.path.join(self.test_media_root, 'diagram_cache', 'mermaid')
+        os.makedirs(cache_dir, exist_ok=True)
+        test_file = os.path.join(cache_dir, 'test.svg')
+        open(test_file, 'w').close()
+
+        # Run command
+        out = StringIO()
+        call_command('clear_diagram_cache', type='mermaid', stdout=out)
+
+        # Check output
+        self.assertIn('Clearing cache for mermaid', out.getvalue())
+        self.assertIn('Cache cleared successfully', out.getvalue())
+
+
+class IntegrationTest(TestCase):
+    """Integration tests with actual dokumente models"""
+
+    def setUp(self):
+        """Set up test data using dokumente models"""
+        from dokumente.models import (
+            Dokumententyp, Dokument, Vorgabe, VorgabeLangtext, Thema
+        )
+        from datetime import date
+
+        # Create required objects
+        self.dokumententyp = Dokumententyp.objects.create(
+            name="Test Policy",
+            verantwortliche_ve="TEST"
+        )
+
+        self.dokument = Dokument.objects.create(
+            nummer="TEST-001",
+            name="Test Document",
+            dokumententyp=self.dokumententyp,
+            aktiv=True
+        )
+
+        self.thema = Thema.objects.create(name="Test Thema")
+        self.vorgabe = Vorgabe.objects.create(
+            dokument=self.dokument,
+            nummer=1,
+            order=1,
+            thema=self.thema,
+            titel="Test Vorgabe",
+            gueltigkeit_von=date.today()
+        )
+
+        # Create AbschnittTypen
+        self.typ_text = AbschnittTyp.objects.create(abschnitttyp="text")
+
+        # Create VorgabeLangtext (which inherits from Textabschnitt)
+        self.langtext = VorgabeLangtext.objects.create(
+            abschnitt=self.vorgabe,
+            abschnitttyp=self.typ_text,
+            inhalt="# Test\n\nThis is a **test** vorgabe.",
+            order=1
+        )
+
+    def test_render_vorgabe_langtext(self):
+        """Test rendering VorgabeLangtext through render_textabschnitte"""
+        from dokumente.models import VorgabeLangtext
+
+        result = render_textabschnitte(
+            VorgabeLangtext.objects.filter(abschnitt=self.vorgabe).order_by('order')
+        )
+
+        self.assertEqual(len(result), 1)
+        typ, html = result[0]
+        self.assertEqual(typ, "text")
+        self.assertIn("<h1>Test</h1>", html)
+        self.assertIn("<strong>test</strong>", html)
+        self.assertIn("vorgabe", html)
+
+    def test_textabschnitt_inheritance(self):
+        """Test that VorgabeLangtext properly inherits Textabschnitt fields"""
+        self.assertEqual(self.langtext.abschnitttyp, self.typ_text)
+        self.assertIn("test", self.langtext.inhalt)
+        self.assertEqual(self.langtext.order, 1)

admin/css/vorgabe_border.css

@@ -0,0 +1,102 @@
+/* Better visual separation for Vorgaben inlines */
+.inline-group[data-inline-model="vorgabe"] {
+    border: 2px solid #ddd;
+    border-radius: 8px;
+    margin-bottom: 20px;
+    padding: 15px;
+    background-color: #f9f9f9;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.inline-group[data-inline-model="vorgabe"] .inline-related {
+    border: 1px solid #ccc;
+    border-radius: 6px;
+    margin-bottom: 10px;
+    background-color: white;
+    padding: 10px;
+}
+
+.inline-group[data-inline-model="vorgabe"] h3 {
+    background-color: #007cba;
+    color: white;
+    padding: 8px 12px;
+    margin: -15px -15px 10px -15px;
+    border-radius: 6px 6px 0 0;
+    font-weight: bold;
+}
+
+.inline-group[data-inline-model="vorgabe"] .collapse .inline-related {
+    border-left: 3px solid #007cba;
+}
+
+/* Better spacing for nested inlines */
+.inline-group[data-inline-model="vorgabe"] .inline-group {
+    margin-top: 10px;
+}
+
+.inline-group[data-inline-model="vorgabe"] .inline-group h3 {
+    background-color: #f0f8ff;
+    color: #333;
+    padding: 6px 10px;
+    margin: 0 0 8px 0;
+    border-left: 3px solid #007cba;
+}
+
+/* Highlight active/expanded vorgabe */
+.inline-group[data-inline-model="vorgabe"] .inline-related:not(.collapsed) {
+    border-color: #007cba;
+    box-shadow: 0 0 8px rgba(0,124,186,0.2);
+}
+
+/* Highlight actively edited vorgabe */
+.inline-group[data-inline-model="vorgabe"] .inline-related.active-edit {
+    border-color: #28a745;
+    box-shadow: 0 0 12px rgba(40,167,69,0.3);
+    background-color: #f8fff9;
+}
+
+/* Toggle hint styling */
+.toggle-hint {
+    font-size: 0.8em;
+    color: #666;
+    font-weight: normal;
+}
+
+/* Better fieldset styling for vorgabe inlines */
+.inline-group[data-inline-model="vorgabe"] .fieldset {
+    border: 1px solid #e0e0e0;
+    border-radius: 4px;
+    padding: 10px;
+    margin-bottom: 10px;
+    background-color: #fafafa;
+}
+
+.inline-group[data-inline-model="vorgabe"] .fieldset h2 {
+    background-color: #e3f2fd;
+    color: #1565c0;
+    padding: 5px 10px;
+    margin: -10px -10px 10px -10px;
+    border-radius: 4px 4px 0 0;
+    font-size: 0.9em;
+    font-weight: bold;
+}
+
+/* Better form layout */
+.inline-group[data-inline-model="vorgabe"] .form-row {
+    border-bottom: 1px solid #eee;
+    padding: 8px 0;
+}
+
+.inline-group[data-inline-model="vorgabe"] .form-row:last-child {
+    border-bottom: none;
+}
+
+/* Wide fields styling */
+.inline-group[data-inline-model="vorgabe"] .wide .form-row > div {
+    width: 100%;
+}
+
+.inline-group[data-inline-model="vorgabe"] .wide textarea {
+    width: 100%;
+    min-height: 80px;
+}

admin/js/vorgabe_toggle.js

@@ -0,0 +1,25 @@
+(function($) {
+    'use strict';
+    
+    $(document).ready(function() {
+        // Add toggle buttons for each vorgabe inline
+        $('.inline-group[data-inline-model="vorgabe"]').each(function() {
+            var $group = $(this);
+            var $headers = $group.find('h3');
+            
+            $headers.css('cursor', 'pointer').append(' <span class="toggle-hint">(klicken zum umschalten)</span>');
+            
+            $headers.on('click', function(e) {
+                e.preventDefault();
+                var $inline = $(this).closest('.inline-related');
+                $inline.find('.collapse').toggleClass('collapsed');
+            });
+        });
+        
+        // Highlight active vorgabe when editing
+        $('.inline-group[data-inline-model="vorgabe"] .inline-related').on('click', function() {
+            $('.inline-group[data-inline-model="vorgabe"] .inline-related').removeClass('active-edit');
+            $(this).addClass('active-edit');
+        });
+    });
+})(django.jQuery);

argocd/deployment.yaml

@@ -25,7 +25,7 @@ spec:
               mountPath: /data
       containers:
         - name: web
-          image: git.baumann.gr/adebaumann/vui:0.938
+          image: git.baumann.gr/adebaumann/vui:0.939
           imagePullPolicy: Always
           ports:
             - containerPort: 8000

dokumente/admin.py

@@ -21,45 +21,75 @@ from referenzen.models import Referenz
 #            'frage': forms.Textarea(attrs={'rows': 1, 'cols': 100}),
 #        }
 
-class ChecklistenfragenInline(NestedTabularInline):
+class ChecklistenfragenInline(NestedStackedInline):
     model=Checklistenfrage
     extra=0
     fk_name="vorgabe"
-#    form=ChecklistenForm
     classes = ['collapse']
+    verbose_name_plural = "Checklistenfragen"
+    fieldsets = (
+        (None, {
+            'fields': ('frage',),
+            'classes': ('wide',),
+        }),
+    )
 
 
-class VorgabeKurztextInline(NestedTabularInline):
+class VorgabeKurztextInline(NestedStackedInline):
     model=VorgabeKurztext
     extra=0
     sortable_field_name = "order"
     show_change_link=True
     classes = ['collapse']
-    #inline=inhalt
+    verbose_name_plural = "Kurztext-Abschnitte"
+    fieldsets = (
+        (None, {
+            'fields': ('abschnitttyp', 'inhalt', 'order'),
+            'classes': ('wide',),
+        }),
+    )
 
-class VorgabeLangtextInline(NestedTabularInline):
+class VorgabeLangtextInline(NestedStackedInline):
     model=VorgabeLangtext
     extra=0
     sortable_field_name = "order"
     show_change_link=True
     classes = ['collapse']
-    #inline=inhalt
+    verbose_name_plural = "Langtext-Abschnitte"
+    fieldsets = (
+        (None, {
+            'fields': ('abschnitttyp', 'inhalt', 'order'),
+            'classes': ('wide',),
+        }),
+    )
 
-class GeltungsbereichInline(NestedTabularInline):
+class GeltungsbereichInline(NestedStackedInline):
     model=Geltungsbereich
     extra=0
     sortable_field_name = "order"
     show_change_link=True
     classes = ['collapse']
-    classes = ['collapse']
-    #inline=inhalt
+    verbose_name_plural = "Geltungsbereich-Abschnitte"
+    fieldsets = (
+        (None, {
+            'fields': ('abschnitttyp', 'inhalt', 'order'),
+            'classes': ('wide',),
+        }),
+    )
 
-class EinleitungInline(NestedTabularInline):
+class EinleitungInline(NestedStackedInline):
     model = Einleitung
     extra = 0
     sortable_field_name = "order"
     show_change_link = True
     classes = ['collapse']
+    verbose_name_plural = "Einleitungs-Abschnitte"
+    fieldsets = (
+        (None, {
+            'fields': ('abschnitttyp', 'inhalt', 'order'),
+            'classes': ('wide',),
+        }),
+    )
 
 class VorgabeForm(forms.ModelForm):
     referenzen = TreeNodeMultipleChoiceField(queryset=Referenz.objects.all(), required=False)
@@ -67,17 +97,31 @@ class VorgabeForm(forms.ModelForm):
         model = Vorgabe
         fields = '__all__'
 
-class VorgabeInline(SortableInlineAdminMixin, NestedTabularInline):  # or StackedInline for more vertical layout
+class VorgabeInline(SortableInlineAdminMixin, NestedStackedInline):
     model = Vorgabe
     form = VorgabeForm
     extra = 0
-    sortable_field_name = "order"  # Add this - make sure your Vorgabe model has an 'order' field
-    #show_change_link = True
-    inlines = [VorgabeKurztextInline,VorgabeLangtextInline,ChecklistenfragenInline]
+    sortable_field_name = "order"
+    show_change_link = False
+    can_delete = False
+    inlines = [VorgabeKurztextInline, VorgabeLangtextInline, ChecklistenfragenInline]
     autocomplete_fields = ['stichworte','referenzen','relevanz']
-    #search_fields=['nummer','name']ModelAdmin.
-    list_filter=['stichworte']
-    #classes=["collapse"]
+    # Remove collapse class so Vorgaben show by default
+    
+    fieldsets = (
+        ('Grunddaten', {
+            'fields': (('order', 'nummer'), ('thema', 'titel')),
+            'classes': ('wide',),
+        }),
+        ('Gültigkeit', {
+            'fields': (('gueltigkeit_von', 'gueltigkeit_bis'),),
+            'classes': ('wide',),
+        }),
+        ('Verknüpfungen', {
+            'fields': (('referenzen', 'stichworte', 'relevanz'),),
+            'classes': ('wide',),
+        }),
+    )
 
 class StichworterklaerungInline(NestedTabularInline):
     model=Stichworterklaerung
@@ -104,25 +148,68 @@ class PersonAdmin(admin.ModelAdmin):
 @admin.register(Dokument)
 class DokumentAdmin(SortableAdminBase, NestedModelAdmin):
     actions_on_top=True
-    inlines = [EinleitungInline,GeltungsbereichInline,VorgabeInline]
-    #filter_horizontal=['autoren','pruefende']
-    list_display=['nummer','name','dokumententyp']
+    inlines = [EinleitungInline, GeltungsbereichInline, VorgabeInline]
+    filter_horizontal=['autoren','pruefende']
+    list_display=['nummer','name','dokumententyp','gueltigkeit_von','gueltigkeit_bis','aktiv']
     search_fields=['nummer','name']
-    class Media:
-#        js = ('admin/js/vorgabe_collapse.js',)
-        css = {
-            'all': ('admin/css/vorgabe_border.css',
-#                    'admin/css/vorgabe_collapse.css',
+    list_filter=['dokumententyp','aktiv','gueltigkeit_von']
+    
+    fieldsets = (
+        ('Grunddaten', {
+            'fields': ('nummer', 'name', 'dokumententyp', 'aktiv'),
+            'classes': ('wide',),
+        }),
+        ('Verantwortlichkeiten', {
+            'fields': ('autoren', 'pruefende'),
+            'classes': ('wide', 'collapse'),
+        }),
+        ('Gültigkeit & Metadaten', {
+            'fields': ('gueltigkeit_von', 'gueltigkeit_bis', 'signatur_cso', 'anhaenge'),
+            'classes': ('wide', 'collapse'),
+        }),
     )
+    
+    class Media:
+        js = ('admin/js/vorgabe_collapse.js',)
+        css = {
+            'all': ('admin/css/vorgabe_border.css',)
         }
 
 
 #admin.site.register(Stichwort)
 
+@admin.register(VorgabenTable)
+class VorgabenTableAdmin(admin.ModelAdmin):
+    list_display = ['order', 'nummer', 'dokument', 'thema', 'titel', 'gueltigkeit_von', 'gueltigkeit_bis']
+    list_display_links = ['dokument']
+    list_editable = ['order', 'nummer', 'thema', 'titel', 'gueltigkeit_von', 'gueltigkeit_bis']
+    list_filter = ['dokument', 'thema', 'gueltigkeit_von', 'gueltigkeit_bis']
+    search_fields = ['nummer', 'titel', 'dokument__nummer', 'dokument__name']
+    autocomplete_fields = ['dokument', 'thema', 'stichworte', 'referenzen', 'relevanz']
+    ordering = ['order']
+    list_per_page = 100
+
+    fieldsets = (
+        ('Grunddaten', {
+            'fields': ('order', 'nummer', 'dokument', 'thema', 'titel')
+        }),
+        ('Gültigkeit', {
+            'fields': ('gueltigkeit_von', 'gueltigkeit_bis')
+        }),
+        ('Verknüpfungen', {
+            'fields': ('referenzen', 'stichworte', 'relevanz'),
+            'classes': ('collapse',)
+        }),
+    )
+
+@admin.register(Thema)
+class ThemaAdmin(admin.ModelAdmin):
+    search_fields = ['name']
+    ordering = ['name']
+
 admin.site.register(Checklistenfrage)
 admin.site.register(Dokumententyp)
 #admin.site.register(Person)
-admin.site.register(Thema)
 #admin.site.register(Referenz, DraggableM§PTTAdmin)
 admin.site.register(Vorgabe)
 

dokumente/models.py

@@ -125,6 +125,12 @@ class Checklistenfrage(models.Model):
         verbose_name_plural="Fragen für Checkliste"
         verbose_name="Frage für Checkliste"
 
+class VorgabenTable(Vorgabe):
+    class Meta:
+        proxy = True
+        verbose_name = "Vorgabe (Tabellenansicht)"
+        verbose_name_plural = "Vorgaben (Tabellenansicht)"
+
 class Changelog(models.Model):
     dokument = models.ForeignKey(Dokument, on_delete=models.CASCADE, related_name='changelog')
     autoren = models.ManyToManyField(Person)

pages/templates/base.html

@@ -28,6 +28,6 @@
     <div class="flex-fill">{% block content %}Main Content{% endblock %}</div>
     <div class="col-md-2">{% block sidebar_right %}{% endblock %}</div>
 </div>
-<div>VorgabenUI v0.936</div>
+<div>VorgabenUI v0.939</div>
 </body>
 </html>

static/admin/css/vorgabe_border.css

@@ -5,7 +5,6 @@
     border-radius: 8px;
     padding: 15px;
     margin-bottom: 50px;
-    background-color: #f9f9f9;
     box-shadow: 0 2px 5px rgba(0,0,0,0.1);
 }
 

static/admin/js/vorgabe_collapse.js

@@ -1,21 +1,58 @@
 window.addEventListener('load', function () {
     setTimeout(() => {
-        const vorgabenBlocks = document.querySelectorAll('.djn-dynamic-form-Standards-vorgabe');
-        console.log("Found", vorgabenBlocks.length, "Vorgaben blocks");
+        // Try different selectors for nested admin vorgabe elements
+        const selectors = [
+            '.djn-dynamic-form-dokumente-vorgabe',
+            '.djn-dynamic-form-Standards-vorgabe',
+            '.inline-related[data-inline-type="stacked"]',
+            '.nested-inline'
+        ];
+        
+        let vorgabenBlocks = [];
+        for (const selector of selectors) {
+            vorgabenBlocks = document.querySelectorAll(selector);
+            if (vorgabenBlocks.length > 0) {
+                console.log("Found", vorgabenBlocks.length, "Vorgaben blocks with selector:", selector);
+                break;
+            }
+        }
+
+        if (vorgabenBlocks.length === 0) {
+            console.log("No Vorgaben blocks found, trying fallback...");
+            // Fallback: look for any inline with vorgabe in the class
+            vorgabenBlocks = document.querySelectorAll('[class*="vorgabe"]');
+        }
 
         vorgabenBlocks.forEach((block, index) => {
-            const header = document.createElement('div');
-            header.className = 'vorgabe-toggle-header';
-            header.innerHTML = `▼ Vorgabe ${index + 1}`;
-            header.style.cursor = 'pointer';
+            // Find the existing title/header within the vorgabe block
+            const existingHeader = block.querySelector('h3, .inline-label, .module h2, .djn-inline-header');
             
-            block.parentNode.insertBefore(header, block);
+            if (existingHeader) {
+                // Make the existing header clickable for collapse/expand
+                existingHeader.style.cursor = 'pointer';
+                existingHeader.addEventListener('click', (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
                     
-            header.addEventListener('click', () => {
-                const isHidden = block.style.display === 'none';
-                block.style.display = isHidden ? '' : 'none';
-                header.innerHTML = `${isHidden ? '▼' : '▶'} Vorgabe ${index + 1}`;
+                    // Find all content to collapse - everything except the header itself
+                    const allChildren = Array.from(block.children);
+                    const contentElements = allChildren.filter(child => child !== existingHeader && !child.contains(existingHeader));
+                    
+                    contentElements.forEach(element => {
+                        const isHidden = element.style.display === 'none';
+                        element.style.display = isHidden ? '' : 'none';
                     });
+                    
+                    // Update the header text to show collapse state
+                    const originalText = existingHeader.textContent.replace(/[▼▶]\s*/, '');
+                    const anyHidden = contentElements.some(el => el.style.display === 'none');
+                    existingHeader.innerHTML = `${anyHidden ? '▶' : '▼'} ${originalText}`;
                 });
-    }, 500); // wait 500ms to allow nested inlines to render
+                
+                // Add initial collapse indicator
+                const originalText = existingHeader.textContent;
+                existingHeader.innerHTML = `▼ ${originalText}`;
+            }
+        });
+    }, 1000); // wait longer to allow nested inlines to render
 });