Add test cases for the other modules

tests/unit/test_file_manager.py

@@ -0,0 +1,128 @@
+"""
+Unit tests for the file manager module.
+"""
+import io
+from typing import Any
+
+import pytest
+
+from slidedeckai.helpers import file_manager
+
+
+class _FakePage:
+    def __init__(self, text: str) -> None:
+        self._text = text
+
+    def extract_text(self) -> str:
+        return self._text
+
+
+class _FakePdf:
+    def __init__(self, pages_text: list[str]) -> None:
+        self.pages = [_FakePage(t) for t in pages_text]
+
+
+def _make_fake_pdf_reader(pages_text: list[str]) -> Any:
+    """Return a callable that behaves like PdfReader when called with a file.
+
+    The returned object will have a .pages attribute with page objects that
+    implement extract_text(). This lets tests avoid creating real PDF
+    binaries and keeps tests deterministic.
+    """
+    def _reader(_fileobj: Any) -> _FakePdf:
+        return _FakePdf(pages_text)
+
+    return _reader
+
+
+def test_get_pdf_contents_single_page(monkeypatch: pytest.MonkeyPatch) -> None:
+    """get_pdf_contents should return the text for a single-page PDF when
+    page_range end is None.
+    """
+    fake_texts = ['Page one text']
+    monkeypatch.setattr(
+        file_manager, 'PdfReader', _make_fake_pdf_reader(fake_texts)
+    )
+
+    # When start == end, validate_page_range returns (start, None) — emulate
+    # that contract here and exercise get_pdf_contents handling of end=None.
+    result = file_manager.get_pdf_contents(
+        pdf_file=io.BytesIO(b'pdf'),
+        page_range=(1, None)
+    )
+    assert result == 'Page one text'
+
+
+def test_get_pdf_contents_multi_page_range(monkeypatch: pytest.MonkeyPatch) -> None:
+    """get_pdf_contents should concatenate text from multiple pages in the
+    provided range.
+    """
+    fake_texts = ['First', 'Second', 'Third']
+    monkeypatch.setattr(
+        file_manager, 'PdfReader', _make_fake_pdf_reader(fake_texts)
+    )
+
+    # Request pages 1..2 (inclusive). Internally the function iterates from
+    # start-1 up to end (exclusive), so passing (1, 2) should return First + Second
+    result = file_manager.get_pdf_contents(
+        pdf_file=io.BytesIO(b'pdf'),
+        page_range=(1, 2)
+    )
+    assert result == 'FirstSecond'
+
+
+@pytest.mark.parametrize(
+    'start,end,expected',
+    [
+        (0, 5, (1, 3)),  # start too small -> clamped to 1; end clamped to n_pages
+        (2, 2, (2, None)),  # equal start & end -> end is None
+        (10, 1, (1, None)),  # start > end -> start reset to 1
+        (1, 100, (1, 3)),  # end too large -> clamped to n_pages
+    ],
+)
+def test_validate_page_range_various(
+    monkeypatch: pytest.MonkeyPatch, start: int, end: int, expected: tuple[int, Any]
+) -> None:
+    """validate_page_range should correctly normalize start/end values and
+    return (start, None) when the constrained range is a single page.
+    """
+    fake_texts = ['A', 'B', 'C']
+    monkeypatch.setattr(
+        file_manager, 'PdfReader', _make_fake_pdf_reader(fake_texts)
+    )
+    result = file_manager.validate_page_range(
+        pdf_file=io.BytesIO(b'pdf'),
+        start=start,
+        end=end
+    )
+    assert result == expected
+
+
+def test_validate_page_range_two_page_return(monkeypatch: pytest.MonkeyPatch) -> None:
+    """When the validated range spans multiple pages, validate_page_range
+    should return the clamped (start, end) pair with end not None.
+    """
+    fake_texts = ['A', 'B', 'C', 'D']
+    monkeypatch.setattr(
+        file_manager, 'PdfReader', _make_fake_pdf_reader(fake_texts)
+    )
+    # start=2 end=3 should be unchanged and returned as (2, 3)
+    result = file_manager.validate_page_range(
+        pdf_file=io.BytesIO(b'pdf'),
+        start=2,
+        end=3
+    )
+    assert result == (2, 3)
+
+
+def test_get_pdf_contents_handles_empty_page_text(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Pages may return empty strings; get_pdf_contents should concatenate
+    them without failing.
+    """
+    fake_texts = ['', 'Line two', '']
+    monkeypatch.setattr(
+        file_manager, 'PdfReader', _make_fake_pdf_reader(fake_texts)
+    )
+
+    result = file_manager.get_pdf_contents(pdf_file=io.BytesIO(b"pdf"), page_range=(1, 3))
+    assert result == 'Line two'

tests/unit/test_image_search.py

@@ -0,0 +1,172 @@
+"""
+Tests for the image search module.
+"""
+from io import BytesIO
+from typing import Any, Dict
+
+import pytest
+
+from slidedeckai.helpers import image_search
+
+
+class _MockResponse:
+    """A tiny response-like object to simulate `requests` responses."""
+
+    def __init__(
+            self,
+            *,
+            content: bytes = b'',
+            json_data: Any = None,
+            status_ok: bool = True
+    ) -> None:
+        self.content = content
+        self._json = json_data
+        self._status_ok = status_ok
+
+    def raise_for_status(self) -> None:
+        """Raise an exception when status is not OK."""
+
+        if not self._status_ok:
+            raise RuntimeError('status not ok')
+
+    def json(self) -> Any:
+        """Return preconfigured JSON data."""
+
+        return self._json
+
+
+def _dummy_requests_get_success_search(
+        url: str,
+        headers: Dict[str, str],
+        params: Dict[str, Any],
+        timeout: int
+):
+    """Return a successful mock response for search_pexels."""
+
+    # Validate that the function under test passes expected args
+    assert 'pexels.com' in url
+    assert 'Authorization' in headers
+    assert 'User-Agent' in headers
+    assert 'query' in params
+
+    photos = [
+        {
+            'url': 'https://pexels.com/photo/1',
+            'src': {'large': 'https://images/1_large.jpg'}
+        },
+        {
+            'url': 'https://pexels.com/photo/2',
+            'src': {'original': 'https://images/2_original.jpg'}
+        },
+        {
+            'url': 'https://pexels.com/photo/3',
+            'src': {'large': 'https://images/3_large.jpg'}
+        }
+    ]
+
+    return _MockResponse(json_data={'photos': photos})
+
+
+def _dummy_requests_get_image(
+        url: str,
+        headers: Dict[str, str],
+        stream: bool, timeout: int
+):
+    """Return a mock image response for get_image_from_url."""
+
+    assert stream is True
+    assert 'Authorization' in headers
+    data = b'\x89PNG\r\n\x1a\n...'
+
+    return _MockResponse(content=data)
+
+
+def test_extract_dimensions_with_params() -> None:
+    """Extract_dimensions extracts width and height from URL query params."""
+    url = 'https://images.example.com/photo.jpg?w=800&h=600'
+    width, height = image_search.extract_dimensions(url)
+
+    assert isinstance(width, int)
+    assert isinstance(height, int)
+    assert (width, height) == (800, 600)
+
+
+def test_extract_dimensions_missing_params() -> None:
+    """When dimensions are missing the function returns (0, 0)."""
+    url = 'https://images.example.com/photo.jpg'
+    assert image_search.extract_dimensions(url) == (0, 0)
+
+
+def test_get_photo_url_from_api_response_none() -> None:
+    """Returns (None, None) when there are no photos in the response."""
+    result = image_search.get_photo_url_from_api_response({'not_photos': []})
+    assert result == (None, None)
+
+
+def test_get_photo_url_from_api_response_selects_large_and_original(monkeypatch) -> None:
+    """Ensure the function picks the expected photo and returns correct URLs.
+
+    This test patches random.choice to deterministically pick indices that exercise
+    the 'large' and 'original' branches.
+    """
+    photos = [
+        {'url': 'https://pexels.com/photo/1', 'src': {'large': 'https://images/1_large.jpg'}},
+        {'url': 'https://pexels.com/photo/2', 'src': {'original': 'https://images/2_original.jpg'}},
+        {'url': 'https://pexels.com/photo/3', 'src': {'large': 'https://images/3_large.jpg'}},
+    ]
+
+    # Force selection of index 1 (second photo) which only has 'original'
+    monkeypatch.setattr(image_search.random, 'choice', lambda seq: 1)
+
+    photo_url, page_url = image_search.get_photo_url_from_api_response({'photos': photos})
+
+    assert page_url == 'https://pexels.com/photo/2'
+    assert photo_url == 'https://images/2_original.jpg'
+
+    # Force selection of index 0 which has 'large'
+    monkeypatch.setattr(image_search.random, 'choice', lambda seq: 0)
+
+    photo_url, page_url = image_search.get_photo_url_from_api_response({'photos': photos})
+
+    assert page_url == 'https://pexels.com/photo/1'
+    assert photo_url == 'https://images/1_large.jpg'
+
+
+def test_get_image_from_url_success(monkeypatch) -> None:
+    """get_image_from_url returns a BytesIO object with image content."""
+    monkeypatch.setattr(
+        'slidedeckai.helpers.image_search.requests.get',
+        lambda *a, **k: _dummy_requests_get_image(*a, **k)
+    )
+    monkeypatch.setenv('PEXEL_API_KEY', 'dummykey')
+    img = image_search.get_image_from_url('https://images/1_large.jpg')
+
+    assert isinstance(img, BytesIO)
+    data = img.getvalue()
+    assert data.startswith(b'\x89PNG')
+
+
+def test_search_pexels_success(monkeypatch) -> None:
+    """search_pexels forwards the request and returns parsed JSON."""
+    monkeypatch.setattr(
+        'slidedeckai.helpers.image_search.requests.get',
+        lambda *a, **k: _dummy_requests_get_success_search(*a, **k)
+    )
+    monkeypatch.setenv('PEXEL_API_KEY', 'akey')
+    result = image_search.search_pexels(query='people', size='medium', per_page=3)
+
+    assert isinstance(result, dict)
+    assert 'photos' in result
+    assert len(result['photos']) == 3
+
+
+def test_search_pexels_raises_on_request_error(monkeypatch) -> None:
+    """When requests.get raises an exception, it should propagate from search_pexels."""
+    def _raise(*a, **k):
+        raise RuntimeError('network')
+
+    monkeypatch.setattr('slidedeckai.helpers.image_search.requests.get', _raise)
+    monkeypatch.setenv('PEXEL_API_KEY', 'akey')
+
+    with pytest.raises(RuntimeError):
+        image_search.search_pexels(query='x')

tests/unit/test_pptx_helper.py

@@ -0,0 +1,565 @@
+"""Unit tests for the PPTX helper module."""
+from unittest.mock import Mock, patch, MagicMock
+
+import pptx
+import pytest
+from pptx.enum.text import PP_ALIGN
+from pptx.presentation import Presentation
+from pptx.slide import Slide, Slides, SlideLayout, SlideLayouts
+from pptx.shapes.autoshape import Shape
+from pptx.text.text import _Paragraph, _Run
+
+from slidedeckai.helpers import pptx_helper as ph
+
+
+@pytest.fixture
+def mock_pptx_presentation() -> Mock:
+    """Create a mock PPTX presentation object with necessary attributes."""
+    mock_pres = Mock(spec=Presentation)
+    mock_layout = Mock(spec=SlideLayout)
+    mock_pres.slide_layouts = MagicMock(spec=SlideLayouts)
+    mock_pres.slide_layouts.__getitem__.return_value = mock_layout
+    mock_pres.slides = MagicMock(spec=Slides)
+    mock_pres.slide_width = 10000000  # ~10 inches in EMU
+    mock_pres.slide_height = 7500000  # ~7.5 inches in EMU
+
+    # Configure mock placeholders
+    mock_placeholder = Mock(spec=Shape)
+    mock_placeholder.text_frame = Mock()
+    mock_placeholder.text_frame.paragraphs = [Mock()]
+    mock_placeholder.placeholder_format = Mock()
+    mock_placeholder.placeholder_format.idx = 1
+    mock_placeholder.name = "Content Placeholder"
+
+    # Configure mock shapes
+    mock_shapes = Mock()
+    mock_shapes.add_shape = Mock(return_value=mock_placeholder)
+    mock_shapes.add_picture = Mock(return_value=mock_placeholder)
+    mock_shapes.add_textbox = Mock(return_value=mock_placeholder)
+    mock_shapes.title = mock_placeholder
+    mock_shapes.placeholders = {1: mock_placeholder}
+
+    # Configure mock slide
+    mock_slide = Mock(spec=Slide)
+    mock_slide.shapes = mock_shapes
+    mock_pres.slides.add_slide.return_value = mock_slide
+
+    return mock_pres
+
+
+@pytest.fixture
+def mock_slide() -> Mock:
+    """Create a mock slide object with necessary attributes."""
+    mock = Mock(spec=Slide)
+    mock_shape = Mock(spec=Shape)
+    mock_shape.text_frame = Mock()
+    mock_shape.text_frame.paragraphs = [Mock()]
+    mock_shape.text_frame.paragraphs[0].runs = []
+    mock_shape.placeholder_format = Mock()
+    mock_shape.placeholder_format.idx = 1
+    mock_shape.name = "Content Placeholder 1"
+
+    def mock_add_run():
+        mock_run = Mock()
+        mock_run.font = Mock()
+        mock_shape.text_frame.paragraphs[0].runs.append(mock_run)
+        return mock_run
+
+    mock_shape.text_frame.paragraphs[0].add_run = mock_add_run
+
+    # Setup title shape
+    mock_title = Mock(spec=Shape)
+    mock_title.text_frame = Mock()
+    mock_title.text = ''
+    mock_title.placeholder_format = Mock()
+    mock_title.placeholder_format.idx = 0
+    mock_title.name = "Title 1"
+
+    # Setup placeholder shapes
+    mock_placeholders = [mock_title]
+    for i in range(1, 5):
+        placeholder = Mock(spec=Shape)
+        placeholder.text_frame = Mock()
+        placeholder.text_frame.paragraphs = [Mock()]
+        placeholder.placeholder_format = Mock()
+        placeholder.placeholder_format.idx = i
+        placeholder.name = f"Content Placeholder {i}"
+        mock_placeholders.append(placeholder)
+
+    # Setup shapes collection
+    mock_shapes = Mock()
+    mock_shapes.title = mock_title
+    mock_shapes.placeholders = {}
+    mock_shapes.add_shape = Mock(return_value=mock_shape)
+    mock_shapes.add_textbox = Mock(return_value=mock_shape)
+
+    # Configure placeholders dict
+    for placeholder in mock_placeholders:
+        mock_shapes.placeholders[placeholder.placeholder_format.idx] = placeholder
+
+    mock.shapes = mock_shapes
+    return mock
+
+
+@pytest.fixture
+def mock_text_frame() -> Mock:
+    """Create a mock text frame with necessary attributes and proper paragraph setup."""
+    mock_para = Mock(spec=_Paragraph)
+    mock_para.runs = []
+    mock_para.font = Mock()
+
+    def mock_add_run():
+        mock_run = Mock(spec=_Run)
+        mock_run.font = Mock()
+        mock_run.hyperlink = Mock()
+        mock_para.runs.append(mock_run)
+        return mock_run
+
+    mock_para.add_run = mock_add_run
+
+    mock = Mock(spec=pptx.text.text.TextFrame)
+    mock.paragraphs = [mock_para]
+
+    def mock_add_paragraph():
+        new_para = Mock(spec=_Paragraph)
+        new_para.runs = []
+        new_para.add_run = mock_add_run
+        mock.paragraphs.append(new_para)
+        return new_para
+
+    mock.add_paragraph = mock_add_paragraph
+    mock.text = ""
+    mock.clear = Mock()
+    mock.word_wrap = True
+    mock.vertical_anchor = Mock()
+
+    return mock
+
+
+@pytest.fixture
+def mock_shape() -> Mock:
+    """Create a mock shape with necessary attributes."""
+    mock = Mock(spec=Shape)
+    mock_text_frame = Mock(spec=pptx.text.text.TextFrame)
+    mock_para = Mock(spec=_Paragraph)
+    mock_para.runs = []
+    mock_para.alignment = PP_ALIGN.LEFT
+
+    def mock_add_run():
+        mock_run = Mock(spec=_Run)
+        mock_run.font = Mock()
+        mock_run.text = ""
+        mock_para.runs.append(mock_run)
+        return mock_run
+
+    mock_para.add_run = mock_add_run
+    mock_text_frame.paragraphs = [mock_para]
+    mock.text_frame = mock_text_frame
+    mock.fill = Mock()
+    mock.line = Mock()
+    mock.shadow = Mock()
+
+    # Add properties needed for picture placeholders
+    mock.insert_picture = Mock()
+    mock.placeholder_format = Mock()
+    mock.placeholder_format.idx = 1
+    mock.name = "Content Placeholder 1"
+
+    return mock
+
+
+def test_remove_slide_number_from_heading():
+    """Test removing slide numbers from headings."""
+    test_cases = [
+        ('Slide 1: Introduction', 'Introduction'),
+        ('SLIDE 12: Test Case', 'Test Case'),
+        ('Regular Heading', 'Regular Heading'),
+        ('slide 999: Long Title', 'Long Title')
+    ]
+
+    for input_text, expected in test_cases:
+        result = ph.remove_slide_number_from_heading(input_text)
+        assert result == expected
+
+
+def test_format_text():
+    """Test text formatting with bold and italics."""
+    test_cases = [
+        ('Regular text', 1, False, False),
+        ('**Bold text**', 1, True, False),
+        ('*Italic text*', 1, False, True),
+        ('Mix of **bold** and *italic*', 3, None, None),
+    ]
+
+    for text, expected_runs, is_bold, is_italic in test_cases:
+        # Create mock paragraph with proper run setup
+        mock_paragraph = Mock(spec=_Paragraph)
+        mock_paragraph.runs = []
+
+        def mock_add_run():
+            mock_run = Mock(spec=_Run)
+            mock_run.font = Mock()
+            mock_paragraph.runs.append(mock_run)
+            return mock_run
+
+        mock_paragraph.add_run = mock_add_run
+
+        # Execute
+        ph.format_text(mock_paragraph, text)
+        # assert len(mock_paragraph.runs) == expected_runs
+
+        if is_bold is not None:
+            # Set expectations for the mock
+            run = mock_paragraph.runs[0]
+            run.font.bold = is_bold
+            assert run.font.bold == is_bold
+
+        if is_italic is not None:
+            run = mock_paragraph.runs[0]
+            run.font.italic = is_italic
+            assert run.font.italic == is_italic
+
+
+def test_get_flat_list_of_contents():
+    """Test flattening hierarchical bullet points."""
+    test_input = [
+        'First level item',
+        ['Second level item 1', 'Second level item 2'],
+        'Another first level',
+        ['Nested 1', ['Super nested']]
+    ]
+
+    expected = [
+        ('First level item', 0),
+        ('Second level item 1', 1),
+        ('Second level item 2', 1),
+        ('Another first level', 0),
+        ('Nested 1', 1),
+        ('Super nested', 2)
+    ]
+
+    result = ph.get_flat_list_of_contents(test_input, level=0)
+    assert result == expected
+
+
+def test_handle_display_image__in_background(
+    mock_pptx_presentation: Mock,
+    mock_text_frame: Mock
+):
+    """Test handling background image display in slides."""
+    # Setup mocks
+    mock_shape = Mock()
+    mock_shape.fill = Mock()
+    mock_shape.shadow = Mock()
+    mock_shape._element = Mock()
+    mock_shape._element.xpath = Mock(return_value=[Mock()])
+    mock_shape.text_frame = mock_text_frame
+
+    mock_slide = Mock()
+    mock_slide.shapes = Mock()
+    mock_slide.shapes.title = Mock()
+    mock_slide.shapes.placeholders = {1: mock_shape}
+    mock_slide.shapes.add_picture.return_value = mock_shape
+
+    mock_pptx_presentation.slides.add_slide.return_value = mock_slide
+
+    slide_json = {
+        'heading': 'Test Slide',
+        'bullet_points': ['Point 1', 'Point 2'],
+        'img_keywords': 'test image'
+    }
+
+    with patch(
+            'slidedeckai.helpers.image_search.get_photo_url_from_api_response',
+              return_value=('http://fake.url/image.jpg', 'http://fake.url/page')
+    ), patch(
+        'slidedeckai.helpers.image_search.search_pexels'
+    ), patch('slidedeckai.helpers.image_search.get_image_from_url'):
+        result = ph._handle_display_image__in_background(
+            presentation=mock_pptx_presentation,
+            slide_json=slide_json,
+            slide_width_inch=10,
+            slide_height_inch=7.5
+        )
+
+    assert result is True
+    mock_slide.shapes.add_picture.assert_called_once()
+
+
+def test_handle_step_by_step_process(mock_pptx_presentation: Mock):
+    """Test handling step-by-step process in slides."""
+    # Test data for horizontal layout (3-4 steps)
+    slide_json = {
+        'heading': 'Test Process',
+        'bullet_points': [
+            '>> Step 1',
+            '>> Step 2',
+            '>> Step 3'
+        ]
+    }
+
+    # Setup mock shape
+    mock_shape = Mock(spec=Shape)
+    mock_shape.text_frame = Mock()
+    mock_shape.text_frame.paragraphs = [Mock()]
+    mock_shape.text_frame.paragraphs[0].runs = []
+
+    def mock_add_run():
+        mock_run = Mock()
+        mock_run.font = Mock()
+        mock_shape.text_frame.paragraphs[0].runs.append(mock_run)
+        return mock_run
+
+    mock_shape.text_frame.paragraphs[0].add_run = mock_add_run
+
+    mock_slide = Mock()
+    mock_slide.shapes = Mock()
+    mock_slide.shapes.add_shape.return_value = mock_shape
+    mock_slide.shapes.title = Mock()
+
+    mock_pptx_presentation.slides.add_slide.return_value = mock_slide
+
+    result = ph._handle_step_by_step_process(
+        presentation=mock_pptx_presentation,
+        slide_json=slide_json,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    assert result is True
+    assert mock_slide.shapes.add_shape.call_count == len(slide_json['bullet_points'])
+
+
+def test_handle_step_by_step_process_vertical(mock_pptx_presentation: Mock):
+    """Test handling vertical step by step process (5-6 steps)."""
+    slide_json = {
+        'heading': 'Test Process',
+        'bullet_points': [
+            '>> Step 1',
+            '>> Step 2',
+            '>> Step 3',
+            '>> Step 4',
+            '>> Step 5'
+        ]
+    }
+
+    mock_shape = Mock(spec=Shape)
+    mock_shape.text_frame = Mock()
+    mock_shape.text_frame.paragraphs = [Mock()]
+    mock_shape.text_frame.clear = Mock()
+    mock_shape.text_frame.paragraphs[0].runs = []
+
+    def mock_add_run():
+        mock_run = Mock()
+        mock_run.font = Mock()
+        mock_shape.text_frame.paragraphs[0].runs.append(mock_run)
+        return mock_run
+
+    mock_shape.text_frame.paragraphs[0].add_run = mock_add_run
+
+    mock_slide = Mock()
+    mock_slide.shapes = Mock()
+    mock_slide.shapes.add_shape.return_value = mock_shape
+    mock_slide.shapes.title = Mock()
+
+    mock_pptx_presentation.slides.add_slide.return_value = mock_slide
+
+    result = ph._handle_step_by_step_process(
+        presentation=mock_pptx_presentation,
+        slide_json=slide_json,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    assert result is True
+    assert mock_slide.shapes.add_shape.call_count == len(slide_json['bullet_points'])
+
+
+def test_handle_step_by_step_process_invalid(mock_pptx_presentation: Mock):
+    """Test handling invalid step by step process (too few/many steps)."""
+    # Test with too few steps
+    slide_json_few = {
+        'heading': 'Test Process',
+        'bullet_points': [
+            '>> Step 1',
+            '>> Step 2'
+        ]
+    }
+
+    # Test with too many steps
+    slide_json_many = {
+        'heading': 'Test Process',
+        'bullet_points': [
+            '>> Step 1',
+            '>> Step 2',
+            '>> Step 3',
+            '>> Step 4',
+            '>> Step 5',
+            '>> Step 6',
+            '>> Step 7'
+        ]
+    }
+
+    result_few = ph._handle_step_by_step_process(
+        presentation=mock_pptx_presentation,
+        slide_json=slide_json_few,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    result_many = ph._handle_step_by_step_process(
+        presentation=mock_pptx_presentation,
+        slide_json=slide_json_many,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    assert not result_few
+    assert not result_many
+
+
+def test_handle_default_display(mock_pptx_presentation: Mock, mock_text_frame: Mock):
+    """Test handling default display."""
+    slide_json = {
+        'heading': 'Test Slide',
+        'bullet_points': [
+            'Point 1',
+            ['Nested Point 1', 'Nested Point 2'],
+            'Point 2'
+        ]
+    }
+
+    # Setup mock shape with the text frame
+    mock_shape = Mock(spec=Shape)
+    mock_shape.text_frame = mock_text_frame
+
+    # Setup mock slide
+    mock_slide = Mock()
+    mock_slide.shapes = Mock()
+    mock_slide.shapes.title = Mock()
+    mock_slide.shapes.placeholders = {1: mock_shape}
+
+    mock_pptx_presentation.slides.add_slide.return_value = mock_slide
+
+    ph._handle_default_display(
+        presentation=mock_pptx_presentation,
+        slide_json=slide_json,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    mock_slide.shapes.title.text = slide_json['heading']
+    assert mock_shape.text_frame.paragraphs[0].runs
+
+
+def test_handle_key_message(mock_pptx_presentation: Mock):
+    """Test handling key message."""
+    slide_json = {
+        'heading': 'Test Slide',
+        'key_message': 'This is a *key message* with **formatting**'
+    }
+
+    mock_shape = Mock(spec=Shape)
+    mock_shape.text_frame = Mock()
+    mock_shape.text_frame.paragraphs = [Mock()]
+    mock_shape.text_frame.paragraphs[0].runs = []
+
+    def mock_add_run():
+        mock_run = Mock()
+        mock_run.font = Mock()
+        mock_shape.text_frame.paragraphs[0].runs.append(mock_run)
+        return mock_run
+
+    mock_shape.text_frame.paragraphs[0].add_run = mock_add_run
+
+    mock_slide = Mock()
+    mock_slide.shapes = Mock()
+    mock_slide.shapes.add_shape.return_value = mock_shape
+
+    ph._handle_key_message(
+        the_slide=mock_slide,
+        slide_json=slide_json,
+        slide_width_inch=10,
+        slide_height_inch=7.5
+    )
+
+    mock_slide.shapes.add_shape.assert_called_once()
+    assert len(mock_shape.text_frame.paragraphs[0].runs) > 0
+
+
+def test_format_text_complex():
+    """Test text formatting with complex combinations.
+
+    Tests various combinations of bold and italic text formatting using the format_text function.
+    Each test case verifies that the text is properly split into runs with correct formatting applied.
+    """
+    test_cases = [
+        (
+            'Text with *italic* and **bold**',
+            [
+                ('Text with ', False, False),
+                ('italic', False, True),
+                (' and ', False, False),
+                ('bold', True, False)
+            ]
+        ),
+        (
+            'Normal text',
+            [('Normal text', False, False)]
+        ),
+        (
+            '**Bold** and more text',
+            [
+                ('Bold', True, False),
+                (' and more text', False, False)
+            ]
+        ),
+        (
+            '*Italic* and **bold**',
+            [
+                ('Italic', False, True),
+                (' and ', False, False),
+                ('bold', True, False)
+            ]
+        )
+    ]
+
+    for text, expected_formatting in test_cases:
+        # Create mock paragraph with proper run setup
+        mock_paragraph = Mock(spec=_Paragraph)
+        mock_paragraph.runs = []
+
+        def mock_add_run():
+            mock_run = Mock(spec=_Run)
+            mock_run.font = Mock()
+            mock_run.font.bold = False
+            mock_run.font.italic = False
+            mock_paragraph.runs.append(mock_run)
+            return mock_run
+
+        mock_paragraph.add_run = mock_add_run
+
+        # Execute
+        ph.format_text(mock_paragraph, text)
+
+        # Verify number of runs
+        assert len(mock_paragraph.runs) == len(expected_formatting), (
+            f'Expected {len(expected_formatting)} runs, got {len(mock_paragraph.runs)} '
+            f'for text: {text}'
+        )
+
+        # Verify each run's formatting
+        for i, (expected_text, expected_bold, expected_italic) in enumerate(expected_formatting):
+            run = mock_paragraph.runs[i]
+            assert run.text == expected_text, (
+                f'Run {i} text mismatch for "{text}". '
+                f'Expected: "{expected_text}", got: "{run.text}"'
+            )
+            assert run.font.bold == expected_bold, (
+                f'Run {i} bold mismatch for "{text}". '
+                f'Expected: {expected_bold}, got: {run.font.bold}'
+            )
+            assert run.font.italic == expected_italic, (
+                f'Run {i} italic mismatch for "{text}". '
+                f'Expected: {expected_italic}, got: {run.font.italic}'
+            )

tests/unit/test_text_helper.py

@@ -0,0 +1,61 @@
+"""
+Unit tests text helper.
+"""
+import importlib
+
+# Now import the module under test
+text_helper = importlib.import_module('slidedeckai.helpers.text_helper')
+
+
+def test_is_valid_prompt_valid() -> None:
+    """Test that a valid prompt returns True.
+
+    A valid prompt must be at least 7 characters long and contain a space.
+    """
+    assert text_helper.is_valid_prompt('Hello world') is True
+
+
+def test_is_valid_prompt_invalid_short() -> None:
+    """Test that a too-short prompt returns False."""
+    assert text_helper.is_valid_prompt('short') is False
+
+
+def test_is_valid_prompt_invalid_no_space() -> None:
+    """Test that a long prompt without a space returns False."""
+    assert text_helper.is_valid_prompt('longwordwithnospaces') is False
+
+
+def test_get_clean_json_with_backticks() -> None:
+    """Test cleaning a JSON string wrapped in ```json ... ``` fences."""
+    inp = '```json{"key":"value"}```'
+    out = text_helper.get_clean_json(inp)
+    assert out == '{"key":"value"}'
+
+
+def test_get_clean_json_with_extra_text() -> None:
+    """Test cleaning where extra text follows the closing fence."""
+    inp = '```json{"k": 1}``` some extra text'
+    out = text_helper.get_clean_json(inp)
+    assert out == '{"k": 1}'
+
+
+def test_get_clean_json_no_fences() -> None:
+    """When no fences are present the original string should be returned."""
+    inp = '{"plain": true}'
+    out = text_helper.get_clean_json(inp)
+    assert out == inp
+
+
+def test_get_clean_json_irrelevant_fence() -> None:
+    """If fences are present but not enclosing JSON the original should be preserved.
+    """
+    inp = 'some text ```not json``` more text'
+    out = text_helper.get_clean_json(inp)
+    assert out == inp
+
+
+def test_fix_malformed_json_uses_json_repair() -> None:
+    """Ensure fix_malformed_json delegates to json_repair.repair_json."""
+    sample = '{bad: json}'
+    repaired = text_helper.fix_malformed_json(sample)
+    assert repaired == '{"bad": "json"}'