diff --git a/abschnitte/tests.py b/abschnitte/tests.py
index 93a0813..7ce503c 100644
--- a/abschnitte/tests.py
+++ b/abschnitte/tests.py
@@ -1,377 +1,3 @@
-from unittest.mock import Mock, patch, MagicMock
-from django.test import TestCase, override_settings
-from abschnitte.models import AbschnittTyp, Textabschnitt
-from abschnitte.utils import render_textabschnitte, md_table_to_html
+from django.test import TestCase
 
-
-class MockTextabschnitt:
-    """Mock object for Textabschnitt (since it's abstract)."""
-    def __init__(self, abschnitttyp, inhalt):
-        self.abschnitttyp = abschnitttyp
-        self.inhalt = inhalt
-
-
-class RenderTextabschnitteTestCase(TestCase):
-    """Test cases for render_textabschnitte function."""
-    
-    def setUp(self):
-        """Set up test fixtures."""
-        # Create mock AbschnittTyp objects
-        self.typ_text = Mock()
-        self.typ_text.abschnitttyp = "text"
-        
-        self.typ_liste_ungeordnet = Mock()
-        self.typ_liste_ungeordnet.abschnitttyp = "liste ungeordnet"
-        
-        self.typ_liste_geordnet = Mock()
-        self.typ_liste_geordnet.abschnitttyp = "liste geordnet"
-        
-        self.typ_tabelle = Mock()
-        self.typ_tabelle.abschnitttyp = "tabelle"
-        
-        self.typ_diagramm = Mock()
-        self.typ_diagramm.abschnitttyp = "diagramm"
-        
-        self.typ_code = Mock()
-        self.typ_code.abschnitttyp = "code"
-    
-    def test_render_basic_text(self):
-        """Test rendering basic text content."""
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_text,
-            inhalt="This is **bold** text with *italic*."
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "text")
-        self.assertIn("<strong>bold</strong>", html)
-        self.assertIn("<em>italic</em>", html)
-    
-    def test_render_unordered_list(self):
-        """Test rendering unordered list."""
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_liste_ungeordnet,
-            inhalt="Item 1\nItem 2\nItem 3"
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        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."""
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_liste_geordnet,
-            inhalt="First item\nSecond item\nThird item"
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "liste geordnet")
-        self.assertIn("<ol>", html)
-        self.assertIn("<li>First item</li>", html)
-    
-    def test_render_table(self):
-        """Test rendering markdown table."""
-        table_content = """| Header 1 | Header 2 |
-|----------|----------|
-| Cell 1   | Cell 2   |
-| Cell 3   | Cell 4   |"""
-        
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_tabelle,
-            inhalt=table_content
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "tabelle")
-        self.assertIn("<table", html)
-        self.assertIn("Header 1", html)
-        self.assertIn("Cell 1", html)
-        self.assertIn("table-bordered", html)
-    
-    @override_settings(MEDIA_URL='/media/')
-    @patch('abschnitte.utils.get_cached_diagram')
-    def test_render_diagram_success(self, mock_get_cached):
-        """Test rendering diagram with successful cache."""
-        mock_get_cached.return_value = 'diagram_cache/plantuml/abc123.svg'
-        
-        diagram_content = """plantuml
-@startuml
-A -> B
-@enduml"""
-        
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_diagramm,
-            inhalt=diagram_content
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "diagramm")
-        
-        # Verify diagram cache was called correctly
-        mock_get_cached.assert_called_once_with(
-            'plantuml',
-            '@startuml\nA -> B\n@enduml'
-        )
-        
-        # Verify HTML contains correct image tag
-        self.assertIn('<img', html)
-        self.assertIn('/media/diagram_cache/plantuml/abc123.svg', html)
-        self.assertIn('width="100%"', html)
-    
-    @patch('abschnitte.utils.get_cached_diagram')
-    def test_render_diagram_with_options(self, mock_get_cached):
-        """Test rendering diagram with custom options."""
-        mock_get_cached.return_value = 'diagram_cache/mermaid/def456.svg'
-        
-        diagram_content = """mermaid
-option:width="50%" height="300px"
-graph TD
-A --> B"""
-        
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_diagramm,
-            inhalt=diagram_content
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        typ, html = result[0]
-        
-        # Verify custom options are used
-        self.assertIn('width="50%"', html)
-        self.assertIn('height="300px"', html)
-        
-        # Verify diagram content doesn't include option line
-        call_args = mock_get_cached.call_args[0]
-        self.assertNotIn('option:', call_args[1])
-    
-    @patch('abschnitte.utils.get_cached_diagram')
-    def test_render_diagram_error(self, mock_get_cached):
-        """Test rendering diagram when caching fails."""
-        mock_get_cached.side_effect = Exception("Kroki server unavailable")
-        
-        diagram_content = """plantuml
-@startuml
-A -> B
-@enduml"""
-        
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_diagramm,
-            inhalt=diagram_content
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        typ, html = result[0]
-        
-        # Should show error message
-        self.assertIn('Error generating diagram', html)
-        self.assertIn('Kroki server unavailable', html)
-        self.assertIn('text-danger', html)
-    
-    def test_render_code(self):
-        """Test rendering code block."""
-        code_content = """def hello():
-    print("Hello, World!")"""
-        
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_code,
-            inhalt=code_content
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        typ, html = result[0]
-        self.assertEqual(typ, "code")
-        self.assertIn("<pre>", html)
-        self.assertIn("<code>", html)
-        self.assertIn("def hello():", html)
-    
-    def test_render_empty_content(self):
-        """Test rendering with empty or None content."""
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=self.typ_text,
-            inhalt=None
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "text")
-        # Should not crash, should return empty or minimal HTML
-    
-    def test_render_multiple_abschnitte(self):
-        """Test rendering multiple sections."""
-        abschnitte = [
-            MockTextabschnitt(self.typ_text, "First paragraph"),
-            MockTextabschnitt(self.typ_liste_ungeordnet, "Item 1\nItem 2"),
-            MockTextabschnitt(self.typ_text, "Second paragraph"),
-        ]
-        
-        result = render_textabschnitte(abschnitte)
-        
-        self.assertEqual(len(result), 3)
-        self.assertEqual(result[0][0], "text")
-        self.assertEqual(result[1][0], "liste ungeordnet")
-        self.assertEqual(result[2][0], "text")
-    
-    def test_render_no_abschnitttyp(self):
-        """Test rendering when abschnitttyp is None."""
-        abschnitt = MockTextabschnitt(
-            abschnitttyp=None,
-            inhalt="Some content"
-        )
-        
-        result = render_textabschnitte([abschnitt])
-        
-        self.assertEqual(len(result), 1)
-        typ, html = result[0]
-        self.assertEqual(typ, "")
-        # Should still render as markdown
-        self.assertIn("Some content", html)
-
-
-class MdTableToHtmlTestCase(TestCase):
-    """Test cases for md_table_to_html function."""
-    
-    def test_basic_table(self):
-        """Test converting basic markdown table to HTML."""
-        md = """| Name | Age |
-|------|-----|
-| Alice | 30 |
-| Bob | 25 |"""
-        
-        html = md_table_to_html(md)
-        
-        self.assertIn('<table', html)
-        self.assertIn('table-bordered', html)
-        self.assertIn('table-hover', html)
-        self.assertIn('<thead>', html)
-        self.assertIn('<tbody>', html)
-        self.assertIn('<th>Name</th>', html)
-        self.assertIn('<th>Age</th>', html)
-        self.assertIn('<td>Alice</td>', html)
-        self.assertIn('<td>30</td>', html)
-    
-    def test_table_with_spaces(self):
-        """Test table with various spacing."""
-        md = """|  Name  |  Age  |
-|--------|-------|
-|  Alice |   30  |
-|   Bob  |  25   |"""
-        
-        html = md_table_to_html(md)
-        
-        # Spaces should be trimmed
-        self.assertIn('<th>Name</th>', html)
-        self.assertIn('<th>Age</th>', html)
-        self.assertIn('<td>Alice</td>', html)
-    
-    def test_table_no_outer_pipes(self):
-        """Test table without outer pipe characters."""
-        md = """Name | Age
------|-----
-Alice | 30
-Bob | 25"""
-        
-        html = md_table_to_html(md)
-        
-        self.assertIn('<th>Name</th>', html)
-        self.assertIn('<td>Alice</td>', html)
-    
-    def test_table_insufficient_rows(self):
-        """Test error handling for malformed table."""
-        md = """| Name |
-|------|"""
-        
-        with self.assertRaises(ValueError) as context:
-            md_table_to_html(md)
-        
-        self.assertIn("at least header + separator", str(context.exception))
-    
-    def test_table_with_empty_cells(self):
-        """Test table with empty cells."""
-        md = """| Name | Age |
-|------|-----|
-| Alice |  |
-|  | 25 |"""
-        
-        html = md_table_to_html(md)
-        
-        self.assertIn('<td>Alice</td>', html)
-        self.assertIn('<td></td>', html)
-        self.assertIn('<td>25</td>', html)
-    
-    def test_table_three_columns(self):
-        """Test table with more columns."""
-        md = """| First | Middle | Last |
-|-------|--------|------|
-| John  | Q      | Doe  |"""
-        
-        html = md_table_to_html(md)
-        
-        self.assertIn('<th>First</th>', html)
-        self.assertIn('<th>Middle</th>', html)
-        self.assertIn('<th>Last</th>', html)
-        self.assertIn('<td>John</td>', html)
-        self.assertIn('<td>Q</td>', html)
-        self.assertIn('<td>Doe</td>', html)
-
-
-class RenderIntegrationTestCase(TestCase):
-    """Integration tests for rendering pipeline."""
-    
-    @patch('abschnitte.utils.get_cached_diagram')
-    def test_mixed_content_rendering(self, mock_get_cached):
-        """Test rendering a mix of different content types."""
-        mock_get_cached.return_value = 'diagram_cache/test.svg'
-        
-        # Create various types of content
-        typ_text = Mock(abschnitttyp="text")
-        typ_liste = Mock(abschnitttyp="liste ungeordnet")
-        typ_diagram = Mock(abschnitttyp="diagramm")
-        
-        abschnitte = [
-            MockTextabschnitt(typ_text, "Introduction paragraph"),
-            MockTextabschnitt(typ_liste, "Point 1\nPoint 2\nPoint 3"),
-            MockTextabschnitt(typ_diagram, "plantuml\n@startuml\nA -> B\n@enduml"),
-            MockTextabschnitt(typ_text, "Conclusion"),
-        ]
-        
-        result = render_textabschnitte(abschnitte)
-        
-        # Should have 4 results
-        self.assertEqual(len(result), 4)
-        
-        # Verify each type was rendered correctly
-        self.assertEqual(result[0][0], "text")
-        self.assertIn("Introduction", result[0][1])
-        
-        self.assertEqual(result[1][0], "liste ungeordnet")
-        self.assertIn("<ul>", result[1][1])
-        
-        self.assertEqual(result[2][0], "diagramm")
-        self.assertIn("<img", result[2][1])
-        
-        self.assertEqual(result[3][0], "text")
-        self.assertIn("Conclusion", result[3][1])
+# Create your tests here.