learning-credentials 0.2.4__tar.gz → 0.3.0__tar.gz

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/CHANGELOG.rst

@@ -16,6 +16,14 @@ Unreleased
 
 *
 
+0.3.0 - 2025-09-17
+******************
+
+Added
+=====
+
+* REST API endpoint to check if credentials are configured for a learning context.
+
 0.2.4 - 2025-09-07
 
 Added

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/MANIFEST.in

@@ -1,6 +1,4 @@
 include CHANGELOG.rst
 include LICENSE.txt
 include README.rst
-include requirements/base.in
-include requirements/constraints.txt
 recursive-include learning_credentials *.html *.png *.gif *.js *.css *.jpg *.jpeg *.svg *.txt

{learning_credentials-0.2.4/learning_credentials.egg-info → learning_credentials-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.2.4
+Version: 0.3.0
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -21,6 +21,8 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: django
 Requires-Dist: django-model-utils
+Requires-Dist: edx-api-doc-tools
+Requires-Dist: edx-django-utils
 Requires-Dist: edx-opaque-keys
 Requires-Dist: celery
 Requires-Dist: django-celery-beat
@@ -122,7 +124,7 @@ file in this repo.
 Reporting Security Issues
 *************************
 
-Please do not report security issues in public. Please email security@openedx.org.
+Please do not report security issues in public. Please email help@opencraft.com.
 
 .. |pypi-badge| image:: https://img.shields.io/pypi/v/learning-credentials.svg
     :target: https://pypi.python.org/pypi/learning-credentials/
@@ -174,6 +176,14 @@ Unreleased
 
 *
 
+0.3.0 - 2025-09-17
+******************
+
+Added
+=====
+
+* REST API endpoint to check if credentials are configured for a learning context.
+
 0.2.4 - 2025-09-07
 
 Added

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/README.rst

@@ -86,7 +86,7 @@ file in this repo.
 Reporting Security Issues
 *************************
 
-Please do not report security issues in public. Please email security@openedx.org.
+Please do not report security issues in public. Please email help@opencraft.com.
 
 .. |pypi-badge| image:: https://img.shields.io/pypi/v/learning-credentials.svg
     :target: https://pypi.python.org/pypi/learning-credentials/

learning_credentials-0.3.0/learning_credentials/api/__init__.py

@@ -0,0 +1 @@
+"""Learning Credentials API package."""

learning_credentials-0.3.0/learning_credentials/api/urls.py

@@ -0,0 +1,9 @@
+"""API URLs."""
+
+from django.urls import include, path
+
+from .v1 import urls as v1_urls
+
+urlpatterns = [
+    path("v1/", include((v1_urls, "learning_credentials_api_v1"), namespace="learning_credentials_api_v1")),
+]

learning_credentials-0.3.0/learning_credentials/api/v1/__init__.py

@@ -0,0 +1 @@
+"""Learning Credentials API v1 package."""

learning_credentials-0.3.0/learning_credentials/api/v1/permissions.py

@@ -0,0 +1,81 @@
+"""Django REST framework permissions."""
+
+from typing import TYPE_CHECKING
+
+from django.db.models import Q
+from learning_paths.models import LearningPath
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import LearningContextKey
+from rest_framework.exceptions import NotFound, ParseError
+from rest_framework.permissions import BasePermission
+
+from learning_credentials.compat import get_course_enrollments
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from learning_paths.keys import LearningPathKey
+    from opaque_keys.edx.keys import CourseKey
+    from rest_framework.request import Request
+    from rest_framework.views import APIView
+
+
+class CanAccessLearningContext(BasePermission):
+    """Permission to allow access to learning context if the user is enrolled."""
+
+    def has_permission(self, request: "Request", view: "APIView") -> bool:
+        """Check if the user can access the learning context."""
+        try:
+            key = view.kwargs.get("learning_context_key") or request.query_params.get("learning_context_key")
+            learning_context_key = LearningContextKey.from_string(key)
+        except InvalidKeyError as e:
+            msg = "Invalid learning context key."
+            raise ParseError(msg) from e
+
+        if request.user.is_staff:
+            return True
+
+        if learning_context_key.is_course:
+            if self._can_access_course(learning_context_key, request.user):
+                return True
+
+            msg = "Course not found or user does not have access."
+            raise NotFound(msg)
+
+        # For learning paths, check enrollment or if it's not invite-only.
+        if self._can_access_learning_path(learning_context_key, request.user):
+            return True
+
+        msg = "Learning path not found or user does not have access."
+        raise NotFound(msg)
+
+    def _can_access_course(self, course_key: "CourseKey", user: "User") -> bool:
+        """Check if user can access a course."""
+        # Check if user is enrolled in the course.
+        if get_course_enrollments(course_key, user.id):  # ty: ignore[unresolved-attribute]
+            return True
+
+        # Check if the course is a part of a learning path the user can access.
+        return self._can_access_course_via_learning_path(course_key, user)
+
+    def _get_accessible_learning_paths_filter(self, user: "User") -> Q:
+        """Get Q filter for learning paths that the user can access."""
+        return Q(invite_only=False) | Q(learningpathenrollment__user=user, learningpathenrollment__is_active=True)
+
+    def _can_access_course_via_learning_path(self, course_key: "CourseKey", user: "User") -> bool:
+        """Check if user can access a course through learning path membership."""
+        accessible_paths = (
+            LearningPath.objects.filter(steps__course_key=course_key)
+            .filter(self._get_accessible_learning_paths_filter(user))
+            .distinct()
+        )
+
+        return accessible_paths.exists()
+
+    def _can_access_learning_path(self, learning_path_key: "LearningPathKey", user: "User") -> bool:
+        """Check if user can access a learning path."""
+        # Single query to check if learning path exists and user can access it
+        accessible_path = LearningPath.objects.filter(key=learning_path_key).filter(
+            self._get_accessible_learning_paths_filter(user)
+        )
+
+        return accessible_path.exists()

learning_credentials-0.3.0/learning_credentials/api/v1/urls.py

@@ -0,0 +1,13 @@
+"""API v1 URLs."""
+
+from django.urls import path
+
+from .views import CredentialConfigurationCheckView
+
+urlpatterns = [
+    path(
+        'configured/<str:learning_context_key>/',
+        CredentialConfigurationCheckView.as_view(),
+        name='credential_configuration_check',
+    ),
+]

learning_credentials-0.3.0/learning_credentials/api/v1/views.py

@@ -0,0 +1,83 @@
+"""API views for Learning Credentials."""
+
+from typing import TYPE_CHECKING
+
+import edx_api_doc_tools as apidocs
+from edx_api_doc_tools import ParameterLocation
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from learning_credentials.models import CredentialConfiguration
+
+from .permissions import CanAccessLearningContext
+
+if TYPE_CHECKING:
+    from rest_framework.request import Request
+
+
+class CredentialConfigurationCheckView(APIView):
+    """API view to check if any credentials are configured for a specific learning context."""
+
+    permission_classes = (IsAuthenticated, CanAccessLearningContext)
+
+    @apidocs.schema(
+        parameters=[
+            apidocs.string_parameter(
+                "learning_context_key",
+                ParameterLocation.PATH,
+                description=(
+                    "Learning context identifier. Can be a course key (course-v1:OpenedX+DemoX+DemoCourse) "
+                    "or learning path key (path-v1:OpenedX+DemoX+DemoPath+Demo)"
+                ),
+            ),
+        ],
+        responses={
+            200: "Boolean indicating if credentials are configured.",
+            400: "Invalid context key format.",
+            403: "User is not authenticated or does not have permission to access the learning context.",
+            404: "Learning context not found or user does not have access.",
+        },
+    )
+    def get(self, _request: "Request", learning_context_key: str) -> Response:
+        """
+        Check if any credentials are configured for the given learning context.
+
+        **Example Request**
+
+        ``GET /api/learning_credentials/v1/configured/course-v1:OpenedX+DemoX+DemoCourse/``
+
+        **Response Values**
+
+        - **200 OK**: Request successful, returns credential configuration status.
+        - **400 Bad Request**: Invalid learning context key format.
+        - **403 Forbidden**: User is not authenticated or does not have permission to access the learning context.
+        - **404 Not Found**: Learning context not found or user does not have access.
+
+        **Example Response**
+
+        .. code-block:: json
+
+            {
+              "has_credentials": true,
+              "credential_count": 2
+            }
+
+        **Response Fields**
+
+        - ``has_credentials``: Boolean indicating if any credentials are configured
+        - ``credential_count``: Number of credential configurations available
+
+        **Note**
+
+        This endpoint does not perform learning context existence validation, so it will not return 404 for staff users.
+        """
+        credential_count = CredentialConfiguration.objects.filter(learning_context_key=learning_context_key).count()
+
+        response_data = {
+            'has_credentials': credential_count > 0,
+            'credential_count': credential_count,
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials/apps.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import ClassVar
 
 from django.apps import AppConfig
+from edx_django_utils.plugins.constants import PluginSettings, PluginURLs
 
 
 class LearningCredentialsConfig(AppConfig):
@@ -15,10 +16,16 @@ class LearningCredentialsConfig(AppConfig):
 
     # https://edx.readthedocs.io/projects/edx-django-utils/en/latest/plugins/how_tos/how_to_create_a_plugin_app.html
     plugin_app: ClassVar[dict[str, dict[str, dict]]] = {
-        'settings_config': {
+        PluginURLs.CONFIG: {
             'lms.djangoapp': {
-                'common': {'relative_path': 'settings.common'},
-                'production': {'relative_path': 'settings.production'},
+                PluginURLs.NAMESPACE: name,
+                PluginURLs.APP_NAME: name,
+            }
+        },
+        PluginSettings.CONFIG: {
+            'lms.djangoapp': {
+                'common': {PluginSettings.RELATIVE_PATH: 'settings.common'},
+                'production': {PluginSettings.RELATIVE_PATH: 'settings.production'},
             },
         },
     }

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials/compat.py

@@ -73,12 +73,15 @@ def get_learning_context_name(learning_context_key: LearningContextKey) -> str:
     return _get_learning_path_name(learning_context_key)
 
 
-def get_course_enrollments(course_id: CourseKey) -> list[User]:
+def get_course_enrollments(course_id: CourseKey, user_id: int | None = None) -> list[User]:
     """Get the course enrollments from Open edX."""
     # noinspection PyUnresolvedReferences,PyPackageRequirements
     from common.djangoapps.student.models import CourseEnrollment
 
     enrollments = CourseEnrollment.objects.filter(course_id=course_id, is_active=True).select_related('user')
+    if user_id:
+        enrollments = enrollments.filter(user__id=user_id)
+
     return [enrollment.user for enrollment in enrollments]
 
 

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials/models.py

@@ -112,7 +112,7 @@ class CredentialConfiguration(TimeStampedModel):
         task_path = f"{task.__wrapped__.__module__}.{task.__wrapped__.__name__}"
 
         if self._state.adding:
-            schedule, created = IntervalSchedule.objects.get_or_create(every=10, period=IntervalSchedule.DAYS)
+            schedule, _created = IntervalSchedule.objects.get_or_create(every=10, period=IntervalSchedule.DAYS)
             self.periodic_task = PeriodicTask.objects.create(
                 enabled=False,
                 interval=schedule,

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials/settings/common.py

@@ -1,9 +1,12 @@
 """App-specific settings for all environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """Add `django_celery_beat` to `INSTALLED_APPS`."""
     if 'django_celery_beat' not in settings.INSTALLED_APPS:
         settings.INSTALLED_APPS += ('django_celery_beat',)

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials/settings/production.py

@@ -1,9 +1,12 @@
 """App-specific settings for production environments."""
 
-from django.conf import Settings
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from django.conf import Settings
 
-def plugin_settings(settings: Settings):
+
+def plugin_settings(settings: 'Settings'):
     """
     Use the database scheduler for Celery Beat.
 

learning_credentials-0.3.0/learning_credentials/urls.py

@@ -0,0 +1,9 @@
+"""URLs for learning_credentials."""
+
+from django.urls import include, path
+
+from .api import urls as api_urls
+
+urlpatterns = [
+    path('api/learning_credentials/', include(api_urls)),
+]

{learning_credentials-0.2.4 → learning_credentials-0.3.0/learning_credentials.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.2.4
+Version: 0.3.0
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -21,6 +21,8 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: django
 Requires-Dist: django-model-utils
+Requires-Dist: edx-api-doc-tools
+Requires-Dist: edx-django-utils
 Requires-Dist: edx-opaque-keys
 Requires-Dist: celery
 Requires-Dist: django-celery-beat
@@ -122,7 +124,7 @@ file in this repo.
 Reporting Security Issues
 *************************
 
-Please do not report security issues in public. Please email security@openedx.org.
+Please do not report security issues in public. Please email help@opencraft.com.
 
 .. |pypi-badge| image:: https://img.shields.io/pypi/v/learning-credentials.svg
     :target: https://pypi.python.org/pypi/learning-credentials/
@@ -174,6 +176,14 @@ Unreleased
 
 *
 
+0.3.0 - 2025-09-17
+******************
+
+Added
+=====
+
+* REST API endpoint to check if credentials are configured for a learning context.
+
 0.2.4 - 2025-09-07
 
 Added

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials.egg-info/SOURCES.txt

@@ -13,13 +13,18 @@ learning_credentials/models.py
 learning_credentials/processors.py
 learning_credentials/tasks.py
 learning_credentials/urls.py
-learning_credentials/views.py
 learning_credentials.egg-info/PKG-INFO
 learning_credentials.egg-info/SOURCES.txt
 learning_credentials.egg-info/dependency_links.txt
 learning_credentials.egg-info/entry_points.txt
 learning_credentials.egg-info/requires.txt
 learning_credentials.egg-info/top_level.txt
+learning_credentials/api/__init__.py
+learning_credentials/api/urls.py
+learning_credentials/api/v1/__init__.py
+learning_credentials/api/v1/permissions.py
+learning_credentials/api/v1/urls.py
+learning_credentials/api/v1/views.py
 learning_credentials/conf/locale/config.yaml
 learning_credentials/migrations/0001_initial.py
 learning_credentials/migrations/0002_migrate_to_learning_credentials.py
@@ -40,4 +45,5 @@ learning_credentials/templates/learning_credentials/edx_ace/certificate_generate
 tests/test_generators.py
 tests/test_models.py
 tests/test_processors.py
-tests/test_tasks.py
+tests/test_tasks.py
+tests/test_views.py

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/learning_credentials.egg-info/requires.txt

@@ -1,5 +1,7 @@
 django
 django-model-utils
+edx-api-doc-tools
+edx-django-utils
 edx-opaque-keys
 celery
 django-celery-beat

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "learning-credentials"
-version = "0.2.4"
+version = "0.3.0"
 description = "A pluggable service for preparing Open edX credentials."
 dynamic = ["readme"]
 requires-python = ">=3.11"
@@ -21,6 +21,8 @@ classifiers = [
 dependencies = [
     "django",  # Web application framework
     "django-model-utils",  # Provides TimeStampedModel abstract base class
+    "edx-api-doc-tools",  # A toolkit for documenting REST APIs that are created with DRF
+    "edx-django-utils",  # Open edX Django utilities (e.g., plugin infrastructure)
     "edx-opaque-keys",  # Create and introspect Course and XBlock identities
     "celery",  # Distributed task queue
     "django-celery-beat",  # Periodic task scheduler
@@ -63,7 +65,7 @@ test = [
     "factory-boy",
 ]
 django42 = ["django>=4.2,<5.0"]
-django52 = ["django>=5.2,<5.3"]
+django52 = ["django>=5.2,<6.0"]
 ci = ["tox", "tox-uv"]
 quality = ["ruff", "yamllint"]
 doc = ["Sphinx", "doc8", "sphinx-book-theme", "twine"]
@@ -74,15 +76,16 @@ dev = [
     { include-group = "doc" },
     "diff-cover",
     "edx-i18n-tools",
+    "ty",  # Type checker.
+    "django-types",  # Type stubs for Django.
     # External dev constraints (DO NOT REMOVE THIS LINE)
-    "Django<5.0",
+    "Django<6.0",
 ]
 
 [tool.uv]
 constraint-dependencies = [
     # External constraints (DO NOT REMOVE THIS LINE)
     "elasticsearch<7.14.0",
-    "pip<24.3",
 ]
 conflicts = [
     [
@@ -178,10 +181,12 @@ ignore = [
 
 [tool.ruff.lint.per-file-ignores]
 'tests/*' = [
-    'S101',   # assert
-    'INP001', # implicit-namespace-package
-    'SLF001', # private-member-access
-    'RUF018', # assignment-in-assert
+    'S101',    # assert
+    'INP001',  # implicit-namespace-package
+    'SLF001',  # private-member-access
+    'RUF018',  # assignment-in-assert
+    'ARG002',  # unused-method-argument
+    'PLR0913', # too-many-arguments
 ]
 
 [tool.ruff.lint.flake8-annotations]
@@ -193,6 +198,11 @@ convention = "google"
 [tool.ruff.lint.pylint]
 allow-magic-value-types = ['int', 'str']
 
+[tool.ruff.lint.flake8-type-checking]
+# Add quotes around type annotations, if doing so would allow
+# an import to be moved into a type-checking block.
+quote-annotations = true
+
 [tool.ruff.format]
 quote-style = "preserve"
 
@@ -207,3 +217,25 @@ filterwarnings = [
 DJANGO_SETTINGS_MODULE = "test_settings"
 addopts = "--cov learning_credentials --cov tests --cov-report term-missing --cov-report xml"
 norecursedirs = ".* docs requirements site-packages"
+
+[tool.ty.rules]
+unresolved-attribute = "warn"
+
+[[tool.ty.overrides]]
+include = ["learning_credentials/settings/*.py"]
+
+[tool.ty.overrides.rules]
+unresolved-attribute = "ignore"
+
+[[tool.ty.overrides]]
+include = ["learning_credentials/compat.py"]
+
+[tool.ty.overrides.rules]
+unresolved-import = "ignore"
+
+[[tool.ty.overrides]]
+include = ["tests/**", "test_utils/**"]
+
+[tool.ty.overrides.rules]
+possibly-unbound-attribute = "ignore"
+unresolved-attribute = "ignore"

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/tests/test_generators.py

@@ -259,7 +259,7 @@ def test_save_credential(mock_contentfile: Mock, mock_token_hex: Mock, storage:
     return_value=Mock(getpdfdata=Mock(return_value=b'pdf_data')),
 )
 @patch('learning_credentials.generators._save_credential', return_value='credential_url')
-def test_generate_pdf_credential(  # noqa: PLR0913
+def test_generate_pdf_credential(
     mock_save_credential: Mock,
     mock_write_text_on_template: Mock,
     mock_pdf_writer: Mock,

{learning_credentials-0.2.4 → learning_credentials-0.3.0}/tests/test_processors.py

@@ -23,6 +23,8 @@ from learning_credentials.processors import (
 from test_utils.factories import UserFactory
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from django.contrib.auth.models import User
 
 
@@ -361,7 +363,7 @@ def learning_path_with_courses(users: list[User]) -> LearningPath:
 @pytest.mark.django_db
 def test_retrieve_data_for_learning_path(
     patch_target: str,
-    function_to_test: callable,
+    function_to_test: Callable[[str, dict], list[int]],
     learning_path_with_courses: LearningPath,
     users: list[User],
 ):

learning_credentials-0.3.0/tests/test_views.py

@@ -0,0 +1,304 @@
+"""Tests for the Learning Credentials API views."""
+
+from typing import TYPE_CHECKING, Union
+from unittest.mock import Mock, patch
+
+import pytest
+from django.urls import reverse
+from learning_paths.keys import LearningPathKey
+from learning_paths.models import LearningPath, LearningPathEnrollment, LearningPathStep
+from opaque_keys.edx.keys import CourseKey
+from rest_framework import status
+from rest_framework.test import APIClient
+
+from learning_credentials.models import CredentialConfiguration, CredentialType
+from test_utils.factories import UserFactory
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from opaque_keys.edx.keys import LearningContextKey
+    from requests import Response
+
+
+@pytest.fixture
+def user() -> UserFactory:
+    """Return a test user."""
+    return UserFactory()
+
+
+@pytest.fixture
+def staff_user() -> UserFactory:
+    """Return a staff user."""
+    return UserFactory(is_staff=True)
+
+
+@pytest.fixture
+def course_key() -> CourseKey:
+    """Return a course key."""
+    return CourseKey.from_string("course-v1:OpenedX+DemoX+DemoCourse")
+
+
+@pytest.fixture
+def learning_path_key() -> LearningPathKey:
+    """Return a learning path key."""
+    return LearningPathKey.from_string("path-v1:OpenedX+DemoX+DemoPath+Demo")
+
+
+@pytest.fixture
+def learning_path(learning_path_key: LearningPathKey) -> LearningPath:
+    """Create an invite-only learning path."""
+    return LearningPath.objects.create(key=learning_path_key)
+
+
+@pytest.fixture
+def public_learning_path(learning_path_key: LearningPathKey) -> LearningPath:
+    """Create a public (non-invite-only) learning path."""
+    return LearningPath.objects.create(key=learning_path_key, invite_only=False)
+
+
+@pytest.fixture
+def learning_path_enrollment(user: "User", learning_path: LearningPath) -> LearningPathEnrollment:
+    """Enroll user in the learning path."""
+    return LearningPathEnrollment.objects.create(learning_path=learning_path, user=user)
+
+
+@pytest.fixture
+def grade_credential_type() -> CredentialType:
+    """Create a grade-based credential type."""
+    return CredentialType.objects.create(
+        name="Certificate of Achievement",
+        retrieval_func="learning_credentials.processors.retrieve_subsection_grades",
+        generation_func="learning_credentials.generators.generate_pdf_credential",
+        custom_options={},
+    )
+
+
+@pytest.fixture
+def completion_credential_type() -> CredentialType:
+    """Create a completion-based credential type."""
+    return CredentialType.objects.create(
+        name="Certificate of Completion",
+        retrieval_func="learning_credentials.processors.retrieve_completions",
+        generation_func="learning_credentials.generators.generate_pdf_credential",
+        custom_options={},
+    )
+
+
+@pytest.fixture
+def grade_config(course_key: CourseKey, grade_credential_type: CredentialType) -> CredentialConfiguration:
+    """Create grade-based credential configuration."""
+    return CredentialConfiguration.objects.create(
+        learning_context_key=course_key,
+        credential_type=grade_credential_type,
+        custom_options={'required_grades': {'Final Exam': 65, 'Overall Grade': 80}},
+    )
+
+
+@pytest.fixture
+def completion_config(course_key: CourseKey, completion_credential_type: CredentialType) -> CredentialConfiguration:
+    """Create completion-based credential configuration."""
+    return CredentialConfiguration.objects.create(
+        learning_context_key=course_key,
+        credential_type=completion_credential_type,
+        custom_options={'required_completion': 100},
+    )
+
+
+def _get_api_client(user: Union["User", None]) -> APIClient:
+    """Return API client for the given user."""
+    client = APIClient()
+    if user:
+        client.force_authenticate(user=user)
+    return client
+
+
+@pytest.mark.django_db
+class TestCredentialConfigurationCheckViewPermissions:
+    """Test permission requirements for credential configuration check endpoint."""
+
+    def _make_request(self, user: Union["User", None], learning_context_key: "LearningContextKey") -> "Response":
+        """Helper to make GET request to the endpoint."""
+        client = _get_api_client(user)
+        url = reverse(
+            'learning_credentials_api_v1:credential_configuration_check',
+            kwargs={'learning_context_key': str(learning_context_key)},
+        )
+        return client.get(url)
+
+    def test_unauthenticated_user_gets_403(self, course_key: CourseKey):
+        """Test that unauthenticated user gets 403."""
+        response = self._make_request(None, course_key)
+        assert response.status_code == status.HTTP_403_FORBIDDEN
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_enrolled_user_can_access_course_check(
+        self, mock_course_enrollments: Mock, user: "User", course_key: CourseKey
+    ):
+        """Test that enrolled user can access course configuration check."""
+        mock_course_enrollments.return_value = [user]
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+        mock_course_enrollments.assert_called_once_with(course_key, user.id)
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments', return_value=[])
+    def test_non_enrolled_user_denied_course_access(
+        self, mock_course_enrollments: Mock, user: "User", course_key: CourseKey
+    ):
+        """Test that non-enrolled user is denied course access."""
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert 'Course not found or user does not have access' in str(response.data)
+
+    def test_enrolled_user_can_access_learning_path_check(
+        self, user: "User", learning_path_enrollment: LearningPathEnrollment
+    ):
+        """Test that enrolled user can access learning path configuration check."""
+        response = self._make_request(user, learning_path_enrollment.learning_path.key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+    def test_non_enrolled_user_denied_learning_path_access(self, user: "User", learning_path: LearningPath):
+        """Test that non-enrolled user is denied learning path access."""
+        response = self._make_request(user, learning_path.key)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert 'Learning path not found or user does not have access' in str(response.data)
+
+    def test_invalid_learning_context_key_returns_400(self, user: "User"):
+        """Test that invalid learning context key returns 400."""
+        response = self._make_request(user, "invalid-key")
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert 'Invalid learning context key' in str(response.data)
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_staff_can_view_any_context_check(
+        self, mock_course_enrollments: Mock, staff_user: "User", course_key: CourseKey
+    ):
+        """Test that staff can view configuration check for any context without enrollment check."""
+        response = self._make_request(staff_user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+        # Staff users bypass enrollment checks.
+        mock_course_enrollments.assert_not_called()
+
+    def test_user_can_access_public_learning_path(self, user: "User", public_learning_path: LearningPath):
+        """Test that any user can access a public (non-invite-only) learning path."""
+        response = self._make_request(user, public_learning_path.key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+    def test_user_cannot_access_invite_only_learning_path_without_enrollment(
+        self, user: "User", learning_path: LearningPath
+    ):
+        """Test that user cannot access invite-only learning path without enrollment."""
+        response = self._make_request(user, learning_path.key)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert 'Learning path not found or user does not have access' in str(response.data)
+
+    def test_enrolled_user_can_access_invite_only_learning_path(self, learning_path_enrollment: LearningPathEnrollment):
+        """Test that enrolled user can access invite-only learning path."""
+        response = self._make_request(learning_path_enrollment.user, learning_path_enrollment.learning_path.key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments', return_value=[])
+    def test_user_can_access_course_via_public_learning_path(
+        self, mock_course_enrollments: Mock, user: "User", course_key: CourseKey, public_learning_path: LearningPath
+    ):
+        """Test that user can access course through membership in a public learning path."""
+        LearningPathStep.objects.create(course_key=course_key, learning_path=public_learning_path)
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments', return_value=[])
+    def test_user_can_access_course_via_enrolled_learning_path(
+        self, mock_course_enrollments: Mock, course_key: CourseKey, learning_path_enrollment: LearningPathEnrollment
+    ):
+        """Test that user can access course through enrollment in learning path containing that course."""
+        LearningPathStep.objects.create(course_key=course_key, learning_path=learning_path_enrollment.learning_path)
+        response = self._make_request(learning_path_enrollment.user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+
+@pytest.mark.django_db
+class TestCredentialConfigurationCheckView:
+    """Test the CredentialConfigurationCheckView functionality."""
+
+    def _make_request(self, user: Union["User", None], learning_context_key: "LearningContextKey") -> "Response":
+        """Helper to make GET request to the endpoint."""
+        client = _get_api_client(user)
+        url = reverse(
+            'learning_credentials_api_v1:credential_configuration_check',
+            kwargs={'learning_context_key': str(learning_context_key)},
+        )
+        return client.get(url)
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_no_credentials_configured(self, mock_course_enrollments: Mock, user: "User", course_key: CourseKey):
+        """Test response when no credentials are configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': False, 'credential_count': 0}
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_single_credential_configured(
+        self, mock_course_enrollments: Mock, user: "User", course_key: CourseKey, grade_config: CredentialConfiguration
+    ):
+        """Test response when one credential is configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': True, 'credential_count': 1}
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_multiple_credentials_configured(
+        self,
+        mock_course_enrollments: Mock,
+        user: "User",
+        course_key: CourseKey,
+        grade_config: CredentialConfiguration,
+        completion_config: CredentialConfiguration,
+    ):
+        """Test response when multiple credentials are configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+        response = self._make_request(user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': True, 'credential_count': 2}
+
+    def test_learning_path_credentials_configured(
+        self, completion_credential_type: CredentialType, learning_path_enrollment: LearningPathEnrollment
+    ):
+        """Test response for learning path context with configured credentials."""
+        CredentialConfiguration.objects.create(
+            learning_context_key=learning_path_enrollment.learning_path.key, credential_type=completion_credential_type
+        )
+        response = self._make_request(learning_path_enrollment.user, learning_path_enrollment.learning_path.key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': True, 'credential_count': 1}
+
+    def test_staff_can_check_any_context(
+        self, staff_user: "User", course_key: CourseKey, grade_config: CredentialConfiguration
+    ):
+        """Test that staff can check configuration for any context without enrollment."""
+        response = self._make_request(staff_user, course_key)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data == {'has_credentials': True, 'credential_count': 1}

learning_credentials-0.2.4/learning_credentials/urls.py

@@ -1,9 +0,0 @@
-"""URLs for learning_credentials."""
-
-# from django.urls import re_path  # noqa: ERA001, RUF100
-# from django.views.generic import TemplateView  # noqa: ERA001, RUF100
-
-urlpatterns = [  # pragma: no cover
-    # TODO: Fill in URL patterns and views here.
-    # re_path(r'', TemplateView.as_view(template_name="learning_credentials/base.html")),  # noqa: ERA001, RUF100
-]

learning_credentials-0.2.4/learning_credentials/views.py

@@ -1 +0,0 @@
-"""TODO."""