learning-credentials 0.4.0rc1__tar.gz → 0.4.0rc3__tar.gz

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3}/CHANGELOG.rst

@@ -24,6 +24,8 @@ Added
 
 * Frontend form and backend API endpoint for verifying credentials.
 * Option to invalidate issued credentials.
+* Support for defining the course name using the `cert_name_long` field (in Studio's Advanced Settings).
+* Support for specifying individual fonts for PDF text elements.
 
 0.3.0 - 2025-09-17
 ******************

{learning_credentials-0.4.0rc1/learning_credentials.egg-info → learning_credentials-0.4.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.4.0rc1
+Version: 0.4.0rc3
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -184,6 +184,8 @@ Added
 
 * Frontend form and backend API endpoint for verifying credentials.
 * Option to invalidate issued credentials.
+* Support for defining the course name using the `cert_name_long` field (in Studio's Advanced Settings).
+* Support for specifying individual fonts for PDF text elements.
 
 0.3.0 - 2025-09-17
 ******************

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3}/learning_credentials/compat.py

@@ -52,10 +52,13 @@ def get_course_grading_policy(course_id: CourseKey) -> dict:
 def _get_course_name(course_id: CourseKey) -> str:
     """Get the course name from Open edX."""
     # noinspection PyUnresolvedReferences,PyPackageRequirements
-    from openedx.core.djangoapps.content.learning_sequences.api import get_course_outline
+    from openedx.core.djangoapps.content.course_overviews.api import get_course_overview_or_none
 
-    course_outline = get_course_outline(course_id)
-    return (course_outline and course_outline.title) or str(course_id)
+    name = str(course_id)
+    if course_overview := get_course_overview_or_none(course_id):
+        name = course_overview.cert_name_long or course_overview.display_name or name
+
+    return name
 
 
 def _get_learning_path_name(learning_path_key: LearningPathKey) -> str:

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3}/learning_credentials/generators.py

@@ -19,9 +19,9 @@ from django.core.files.base import ContentFile
 from django.core.files.storage import FileSystemStorage, default_storage
 from pypdf import PdfReader, PdfWriter
 from pypdf.constants import UserAccessPermissions
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.pdfgen import canvas
+from reportlab.pdfbase.pdfmetrics import FontError, FontNotFoundError, registerFont
+from reportlab.pdfbase.ttfonts import TTFError, TTFont
+from reportlab.pdfgen.canvas import Canvas
 
 from .compat import get_default_storage_url, get_learning_context_name, get_localized_credential_date
 from .models import CredentialAsset
@@ -33,6 +33,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
     from django.contrib.auth.models import User
     from opaque_keys.edx.keys import CourseKey
+    from pypdf import PageObject
 
 
 def _get_user_name(user: User) -> str:
@@ -45,25 +46,29 @@ def _get_user_name(user: User) -> str:
     return user.profile.name or f"{user.first_name} {user.last_name}"
 
 
-def _register_font(options: dict[str, Any]) -> str:
+def _register_font(font_name: Any) -> str | None:  # noqa: ANN401
     """
     Register a custom font if specified in options. If not specified, use the default font (Helvetica).
 
-    :param options: A dictionary containing the font.
-    :returns: The font name.
+    :param font_name: The name of the font to register.
+    :returns: The font name if registered successfully, otherwise None.
     """
-    if font := options.get('font'):
-        pdfmetrics.registerFont(TTFont(font, CredentialAsset.get_asset_by_slug(font)))
+    if not font_name:
+        return None
 
-    return font or 'Helvetica'
+    try:
+        registerFont(TTFont(font_name, CredentialAsset.get_asset_by_slug(font_name)))
+    except (FontError, FontNotFoundError, TTFError):
+        log.exception("Error registering font %s", font_name)
+    else:
+        return font_name
 
 
-def _write_text_on_template(template: any, font: str, username: str, context_name: str, options: dict[str, Any]) -> any:
+def _write_text_on_template(template: PageObject, username: str, context_name: str, options: dict[str, Any]) -> Canvas:
     """
     Prepare a new canvas and write the user and course name onto it.
 
     :param template: Pdf template.
-    :param font: Font name.
     :param username: The name of the user to generate the credential for.
     :param context_name: The name of the learning context.
     :param options: A dictionary documented in the `generate_pdf_credential` function.
@@ -86,19 +91,26 @@ def _write_text_on_template(template: any, font: str, username: str, context_nam
         return tuple(int(hex_color[i : i + 2], 16) / 255 for i in range(0, 6, 2))
 
     template_width, template_height = template.mediabox[2:]
-    pdf_canvas = canvas.Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+    pdf_canvas = Canvas(io.BytesIO(), pagesize=(template_width, template_height))
+    font = _register_font(options.get('font')) or 'Helvetica'
 
     # Write the learner name.
-    pdf_canvas.setFont(font, options.get('name_size', 32))
+    if options.get('name_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_NAME_UPPERCASE', False)):
+        username = username.upper()
+
+    name_font = _register_font(options.get('name_font')) or font
+    pdf_canvas.setFont(name_font, options.get('name_size', 32))
     name_color = options.get('name_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(name_color))
 
     name_x = (template_width - pdf_canvas.stringWidth(username)) / 2
     name_y = options.get('name_y', 290)
+
     pdf_canvas.drawString(name_x, name_y, username)
 
     # Write the learning context name.
-    pdf_canvas.setFont(font, options.get('context_name_size', 28))
+    context_name_font = _register_font(options.get('context_name_font')) or font
+    pdf_canvas.setFont(context_name_font, options.get('context_name_size', 28))
     context_name_color = options.get('context_name_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(context_name_color))
 
@@ -113,13 +125,22 @@ def _write_text_on_template(template: any, font: str, username: str, context_nam
 
     # Write the issue date.
     issue_date = get_localized_credential_date()
-    pdf_canvas.setFont(font, 12)
+    if options.get('issue_date_uppercase', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_UPPERCASE', False)):
+        issue_date = issue_date.upper()
+
+    issue_date_font = _register_font(options.get('issue_date_font')) or font
+    pdf_canvas.setFont(issue_date_font, options.get('issue_date_size', 12))
     issue_date_color = options.get('issue_date_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(issue_date_color))
 
     issue_date_x = (template_width - pdf_canvas.stringWidth(issue_date)) / 2
     issue_date_y = options.get('issue_date_y', 120)
-    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date)
+
+    issue_date_char_space = options.get(
+        'issue_date_char_space', getattr(settings, 'LEARNING_CREDENTIALS_ISSUE_DATE_CHAR_SPACE', 0)
+    )
+
+    pdf_canvas.drawString(issue_date_x, issue_date_y, issue_date, charSpace=issue_date_char_space)
 
     return pdf_canvas
 
@@ -168,7 +189,7 @@ def generate_pdf_credential(
     credential_uuid: UUID,
     options: dict[str, Any],
 ) -> str:
-    """
+    r"""
     Generate a PDF credential.
 
     :param learning_context_key: The ID of the course or learning path the credential is for.
@@ -179,33 +200,48 @@ def generate_pdf_credential(
 
     Options:
       - template: The path to the PDF template file.
-      - template_two_lines: The path to the PDF template file for two-line context names.
-        A two-line context name is specified by using a semicolon as a separator.
-      - font: The name of the font to use.
+      - template_multiline: The path to the PDF template file for multiline context names.
+        A multiline context name is specified by using '\n' or ';' as a separator.
+      - font: The name of the font to use. The default font is Helvetica.
       - name_y: The Y coordinate of the name on the credential (vertical position on the template).
       - name_color: The color of the name on the credential (hexadecimal color code).
       - name_size: The font size of the name on the credential. The default value is 32.
-      - context_name: Specify the custom course or Learning Path name.
+      - name_font: The font of the name on the credential. It overrides the `font` option.
+      - name_uppercase: If set to true (without quotes), the name will be converted to uppercase.
+        The default value is False, unless specified otherwise in the instance settings.
+      - context_name: Specify the custom course or Learning Path name. If not provided, it will be retrieved
+        automatically from the "cert_name_long" or "display_name" fields for courses, or from the Learning Path model.
       - context_name_y: The Y coordinate of the context name on the credential (vertical position on the template).
       - context_name_color: The color of the context name on the credential (hexadecimal color code).
       - context_name_size: The font size of the context name on the credential. The default value is 28.
+      - context_name_font: The font of the context name on the credential. It overrides the `font` option.
       - issue_date_y: The Y coordinate of the issue date on the credential (vertical position on the template).
       - issue_date_color: The color of the issue date on the credential (hexadecimal color code).
+      - issue_date_size: The font size of the issue date on the credential. The default value is 12.
+      - issue_date_font: The font of the issue date on the credential. It overrides the `font` option.
+      - issue_date_char_space: The character spacing of the issue date on the credential
+        (default is 0.0, unless specified otherwise in the instance settings).
+      - issue_date_uppercase: If set to true (without quotes), the issue date will be converted to uppercase.
+        The default value is False, unless specified otherwise in the instance settings.
     """
     log.info("Starting credential generation for user %s", user.id)
 
     username = _get_user_name(user)
     context_name = options.get('context_name') or get_learning_context_name(learning_context_key)
+    template_path = options.get('template')
 
-    # Get template from the CredentialAsset.
-    # HACK: We support two-line strings by using a semicolon as a separator.
-    if ';' in context_name and (template_path := options.get('template_two_lines')):
-        template_file = CredentialAsset.get_asset_by_slug(template_path)
-        context_name = context_name.replace(';', '\n')
-    else:
-        template_file = CredentialAsset.get_asset_by_slug(options['template'])
+    # Handle multiline context name (we support semicolon as a separator to preserve backward compatibility).
+    context_name = context_name.replace(';', '\n').replace(r'\n', '\n')
+    if '\n' in context_name:
+        # `template_two_lines` is kept for backward compatibility.
+        template_path = options.get('template_multiline', options.get('template_two_lines', template_path))
+
+    if not template_path:
+        msg = "Template path must be specified in options."
+        raise ValueError(msg)
 
-    font = _register_font(options)
+    # Get template from the CredentialAsset.
+    template_file = CredentialAsset.get_asset_by_slug(template_path)
 
     # Load the PDF template.
     with template_file.open('rb') as template_file:
@@ -214,7 +250,7 @@ def generate_pdf_credential(
         credential = PdfWriter()
 
         # Create a new canvas, prepare the page and write the data
-        pdf_canvas = _write_text_on_template(template, font, username, context_name, options)
+        pdf_canvas = _write_text_on_template(template, username, context_name, options)
 
         overlay_pdf = PdfReader(io.BytesIO(pdf_canvas.getpdfdata()))
         template.merge_page(overlay_pdf.pages[0])

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3/learning_credentials.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.4.0rc1
+Version: 0.4.0rc3
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -184,6 +184,8 @@ Added
 
 * Frontend form and backend API endpoint for verifying credentials.
 * Option to invalidate issued credentials.
+* Support for defining the course name using the `cert_name_long` field (in Studio's Advanced Settings).
+* Support for specifying individual fonts for PDF text elements.
 
 0.3.0 - 2025-09-17
 ******************

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "learning-credentials"
-version = "0.4.0-rc1"
+version = "0.4.0-rc3"
 description = "A pluggable service for preparing Open edX credentials."
 dynamic = ["readme"]
 requires-python = ">=3.11"
@@ -188,6 +188,7 @@ ignore = [
     'RUF018',  # assignment-in-assert
     'ARG002',  # unused-method-argument
     'PLR0913', # too-many-arguments
+    'FBT001',  # flake8-boolean-trap
 ]
 
 [tool.ruff.lint.flake8-annotations]

{learning_credentials-0.4.0rc1 → learning_credentials-0.4.0rc3}/tests/test_generators.py

@@ -17,6 +17,7 @@ from pypdf import PdfWriter
 from pypdf.constants import UserAccessPermissions
 
 from learning_credentials.generators import (
+    FontError,
     _get_user_name,
     _register_font,
     _save_credential,
@@ -42,25 +43,38 @@ def test_get_user_name():
 def test_register_font_without_custom_font(mock_get_asset_by_slug: Mock):
     """Test the _register_font falls back to the default font when no custom font is specified."""
     options = {}
-    assert _register_font(options) == "Helvetica"
+    assert _register_font(options) is None
     mock_get_asset_by_slug.assert_not_called()
 
 
 @patch("learning_credentials.generators.CredentialAsset.get_asset_by_slug")
 @patch('learning_credentials.generators.TTFont')
-@patch("learning_credentials.generators.pdfmetrics.registerFont")
+@patch("learning_credentials.generators.registerFont")
 def test_register_font_with_custom_font(mock_register_font: Mock, mock_font_class: Mock, mock_get_asset_by_slug: Mock):
     """Test the _register_font registers the custom font when specified."""
     custom_font = "MyFont"
-    options = {"font": custom_font}
-
     mock_get_asset_by_slug.return_value = "font_path"
 
-    assert _register_font(options) == custom_font
+    assert _register_font(custom_font) == custom_font
     mock_get_asset_by_slug.assert_called_once_with(custom_font)
     mock_font_class.assert_called_once_with(custom_font, mock_get_asset_by_slug.return_value)
     mock_register_font.assert_called_once_with(mock_font_class.return_value)
 
+@patch("learning_credentials.generators.CredentialAsset.get_asset_by_slug")
+@patch('learning_credentials.generators.TTFont', side_effect=FontError("Font registration failed"))
+@patch("learning_credentials.generators.registerFont")
+def test_register_font_with_registration_failure(
+    mock_register_font: Mock, mock_font_class: Mock, mock_get_asset_by_slug: Mock
+):
+    """Test the _register_font returns None when font registration fails."""
+    custom_font = "MyFont"
+    mock_get_asset_by_slug.return_value = "font_path"
+
+    assert _register_font(custom_font) is None
+    mock_get_asset_by_slug.assert_called_once_with(custom_font)
+    mock_font_class.assert_called_once_with(custom_font, mock_get_asset_by_slug.return_value)
+    mock_register_font.assert_not_called()
+
 
 @pytest.mark.parametrize(
     ("context_name", "options", "expected"),
@@ -87,7 +101,7 @@ def test_register_font_with_custom_font(mock_register_font: Mock, mock_font_clas
         ('Programming\n101\nAdvanced Programming', {}, {}),  # Multiline course name.
     ],
 )
-@patch('learning_credentials.generators.canvas.Canvas', return_value=Mock(stringWidth=Mock(return_value=10)))
+@patch('learning_credentials.generators.Canvas', return_value=Mock(stringWidth=Mock(return_value=10)))
 def test_write_text_on_template(mock_canvas_class: Mock, context_name: str, options: dict[str, int], expected: dict):
     """Test the _write_text_on_template function."""
     username = 'John Doe'
@@ -106,7 +120,7 @@ def test_write_text_on_template(mock_canvas_class: Mock, context_name: str, opti
 
     # Call the function with test parameters and mocks
     with patch('learning_credentials.generators.get_localized_credential_date', return_value=test_date):
-        _write_text_on_template(template_mock, font, username, context_name, options)
+        _write_text_on_template(template_mock, username, context_name, options)
 
     # Verifying that Canvas was the correct pagesize.
     # Use `call_args_list` to ignore the first argument, which is an instance of io.BytesIO.
@@ -155,6 +169,90 @@ def test_write_text_on_template(mock_canvas_class: Mock, context_name: str, opti
     assert canvas_object.drawString.mock_calls[-1][1] == (expected_issue_date_x, expected_issue_date_y, test_date)
 
 
+@pytest.mark.parametrize(
+    ("option_value", "setting_value", "expected_uppercase"),
+    [
+        (None, False, False),  # No option set, setting is False - use default (lowercase)
+        (None, True, True),  # No option set, setting is True - use setting (uppercase)
+        (False, False, False),  # Explicitly disabled, setting is False
+        (False, True, False),  # Explicitly disabled, setting is True - option overrides
+        (True, False, True),  # Explicitly enabled, setting is False - option overrides
+        (True, True, True),  # Explicitly enabled, setting is True
+    ],
+)
+@patch('learning_credentials.generators.get_localized_credential_date', return_value='April 1, 2021')
+@patch('learning_credentials.generators.Canvas', return_value=Mock(stringWidth=Mock(return_value=10)))
+def test_write_text_on_template_uppercase(
+    mock_canvas_class: Mock,
+    mock_get_date: Mock,
+    option_value: bool | None,
+    setting_value: bool,
+    expected_uppercase: bool,
+):
+    """Test the _write_text_on_template function with uppercase option and settings."""
+    username = "John Doe"
+    context_name = "Programming 101"
+    template_mock = Mock(mediabox=[0, 0, 300, 200])
+    options = {}
+
+    if expected_uppercase:
+        expected_name = "JOHN DOE"
+        expected_date = "APRIL 1, 2021"
+    else:
+        expected_name = username
+        expected_date = mock_get_date.return_value
+
+    if option_value is not None:
+        options['name_uppercase'] = option_value
+        options['issue_date_uppercase'] = option_value
+
+    with override_settings(
+        LEARNING_CREDENTIALS_NAME_UPPERCASE=setting_value,
+        LEARNING_CREDENTIALS_ISSUE_DATE_UPPERCASE=setting_value,
+    ):
+        _write_text_on_template(template_mock, username, context_name, options)
+
+    assert mock_canvas_class.return_value.drawString.mock_calls[-3][1][2] == expected_name
+    assert mock_canvas_class.return_value.drawString.mock_calls[-1][1][2] == expected_date
+
+
+@pytest.mark.parametrize(
+    ("option_value", "setting_value", "expected_char_space"),
+    [
+        (None, 0, 0),  # No option set, setting is 0 - use default
+        (None, 2, 2),  # No option set, setting has value - use setting
+        (0, 0, 0),  # Explicitly set to 0, setting is 0
+        (0, 2, 0),  # Explicitly set to 0, setting has value - option overrides
+        (3, 0, 3),  # Explicitly set to 3, setting is 0 - option overrides
+        (3, 2, 3),  # Explicitly set to 3, setting has value - option overrides
+    ],
+)
+@patch('learning_credentials.generators.get_localized_credential_date', return_value='April 1, 2021')
+@patch('learning_credentials.generators.Canvas', return_value=Mock(stringWidth=Mock(return_value=10)))
+def test_write_text_on_template_issue_date_char_space(
+    mock_canvas_class: Mock,
+    _mock_get_date: Mock,  # noqa: PT019
+    option_value: int | None,
+    setting_value: int,
+    expected_char_space: int,
+):
+    """Test the _write_text_on_template function with issue_date_char_space option and settings."""
+    username = "John Doe"
+    context_name = "Programming 101"
+    template_mock = Mock(mediabox=[0, 0, 300, 200])
+    options = {}
+
+    if option_value is not None:
+        options['issue_date_char_space'] = option_value
+
+    with override_settings(LEARNING_CREDENTIALS_ISSUE_DATE_CHAR_SPACE=setting_value):
+        _write_text_on_template(template_mock, username, context_name, options)
+
+    # Check that the last drawString call (for issue date) has the correct charSpace parameter
+    last_draw_call = mock_canvas_class.return_value.drawString.mock_calls[-1]
+    assert last_draw_call[2]['charSpace'] == expected_char_space
+
+
 @override_settings(LMS_ROOT_URL="https://example.com", MEDIA_URL="media/")
 @pytest.mark.parametrize(
     "storage",
@@ -222,20 +320,22 @@ def test_save_credential(mock_contentfile: Mock, mock_token_hex: Mock, storage:
     ("context_name", "options", "expected_template_slug", "expected_context_name"),
     [
         # Default.
-        ('Test Course', {'template': 'template_slug'}, 'template_slug', 'Test Course'),
-        # Specify a different template for two-line course names and replace semicolon with newline in course name.
-        (
-            'Test Course; Test Course',
-            {'template': 'template_slug', 'template_two_lines': 'template_two_lines_slug'},
-            'template_two_lines_slug',
-            'Test Course\n Test Course',
-        ),
-        # Do not replace semicolon with newline when the `template_two_lines` option is not specified.
-        ('Test Course; Test Course', {'template': 'template_slug'}, 'template_slug', 'Test Course; Test Course'),
+        ('Test Course', {'template': 'default'}, 'default', 'Test Course'),
         # Override course name.
-        ('Test Course', {'template': 'template_slug', 'context_name': 'Override'}, 'template_slug', 'Override'),
+        ('Test Course', {'template': 'default', 'context_name': 'Override'}, 'default', 'Override'),
         # Ignore empty course name override.
-        ('Test Course', {'template': 'template_slug', 'context_name': ''}, 'template_slug', 'Test Course'),
+        ('Test Course', {'template': 'default', 'context_name': ''}, 'default', 'Test Course'),
+        # Specify a different template for multiline course names and replace \n with newline.
+        ('Test\nCourse', {'template': 'default', 'template_multiline': 'multiline'}, 'multiline', 'Test\nCourse'),
+        ('Test\\nCourse', {'template_multiline': 'multiline'}, 'multiline', 'Test\nCourse'),
+        # Backward compatibility with semicolon separator.
+        ('Test;Course', {'template_multiline': 'multiline'}, 'multiline', 'Test\nCourse'),
+        # Mixed semicolon and newline separators.
+        ('Te\nst\\nCourse;', {'template_multiline': 'multiline'}, 'multiline', 'Te\nst\nCourse\n'),
+        # Check backward compatibility with `template_two_lines` option.
+        ('Test\\nCourse', {'template': 'default', 'template_two_lines': 'two_lines'}, 'two_lines', 'Test\nCourse'),
+        # Ensure that the default template is used when no multiline template is specified.
+        ('Test\\nCourse', {'template': 'default'}, 'default', 'Test\nCourse'),
     ],
 )
 @patch(
@@ -251,7 +351,6 @@ def test_save_credential(mock_contentfile: Mock, mock_token_hex: Mock, storage:
 )
 @patch('learning_credentials.generators._get_user_name')
 @patch('learning_credentials.generators.get_learning_context_name')
-@patch('learning_credentials.generators._register_font')
 @patch('learning_credentials.generators.PdfReader')
 @patch('learning_credentials.generators.PdfWriter')
 @patch(
@@ -264,7 +363,6 @@ def test_generate_pdf_credential(
     mock_write_text_on_template: Mock,
     mock_pdf_writer: Mock,
     mock_pdf_reader: Mock,
-    mock_register_font: Mock,
     mock_get_learning_context_name: Mock,
     mock_get_user_name: Mock,
     mock_get_asset_by_slug: Mock,
@@ -287,7 +385,6 @@ def test_generate_pdf_credential(
         mock_get_learning_context_name.assert_not_called()
     else:
         mock_get_learning_context_name.assert_called_once_with(course_id)
-    mock_register_font.assert_called_once_with(options)
     assert mock_pdf_reader.call_count == 2
     mock_pdf_writer.assert_called_once_with()
 
@@ -297,3 +394,17 @@ def test_generate_pdf_credential(
     assert args[-1] == options
 
     mock_save_credential.assert_called_once()
+
+@patch('learning_credentials.generators.get_learning_context_name')
+@patch('learning_credentials.generators._get_user_name')
+def test_generate_pdf_credential_no_template(mock_get_user_name: Mock, mock_get_learning_context_name: Mock):
+    """Test that generate_pdf_credential raises ValueError when no template is specified."""
+    course_id = CourseKey.from_string('course-v1:edX+DemoX+Demo_Course')
+    user = Mock()
+    options = {}  # No template specified.
+
+    with pytest.raises(ValueError, match=r"Template path must be specified in options."):
+        generate_pdf_credential(course_id, user, Mock(), options)
+
+    mock_get_user_name.assert_called_once_with(user)
+    mock_get_learning_context_name.assert_called_once_with(course_id)