lti-client-mock 0.0.1__tar.gz

lti_client_mock-0.0.1/.env

@@ -0,0 +1,7 @@
+LTI_CLIENT_MOCK__LTI = '{"http://localhost:8484": [{"client_id": "lti-provider-mock", "auth_login_url": "http://localhost:8484/authorize", "auth_token_url": "http://localhost:8484/token", "key_set_url": "http://localhost:8484/jwks", "deployment_ids": ["1"]}]}'
+LTI_PROVIDER_MOCK__AUTH_USERS = []
+LTI_PROVIDER_MOCK__USERS = [{"id": "1", "given_name": "The", "family_name": "Admin", "email": "admin@example.com"}, {"id": "2", "given_name": "A", "family_name": "User", "email": "user1@example.com"}]
+LTI_PROVIDER_MOCK__COURSES = [{"id": "1", "name": "Course 1"}, {"id": "2", "name": "Course 2", "users": ["2"]}]
+LTI_PROVIDER_MOCK__LTI__ISS = http://localhost:8484
+LTI_PROVIDER_MOCK__LTI__LOGIN_URL = http://localhost:8485/login
+LTI_PROVIDER_MOCK__LTI__LAUNCH_URL = http://localhost:8485/launch

lti_client_mock-0.0.1/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  # Check for updates of all GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  # Check for updates of all Python packages
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"

lti_client_mock-0.0.1/.github/workflows/codestyle.yml

@@ -0,0 +1,41 @@
+name: Code Style
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python_version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python_version }}
+
+      - name: Add .local path
+        run: |
+          echo "PATH=$HOME/.local/bin:$PATH" >> $GITHUB_ENV
+          echo "PIPX_HOME=$HOME/.local/pipx" >> $GITHUB_ENV
+          echo "PIPX_BIN_DIR=$HOME/.local/bin" >> $GITHUB_ENV
+
+      - name: Install Base Dependencies
+        run: |
+          sudo apt-get install python3-venv pipx
+          pipx install hatch
+
+      - name: Run Ruff check
+        run: |
+          hatch run ruff-check
+
+      - name: Run Ruff format check
+        run: |
+          hatch run ruff-format

lti_client_mock-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,39 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  id-token: write
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+      url: https://pypi.org/project/lti-client-mock
+
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: |
+            3.11
+
+      - name: Install Base Dependencies
+        run: |
+          pip install --user build
+
+      - name: Build the package
+        run: |
+          python -m build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

lti_client_mock-0.0.1/.github/workflows/tests.yml

@@ -0,0 +1,37 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python_version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python_version }}
+
+      - name: Add .local path
+        run: |
+          echo "PATH=$HOME/.local/bin:$PATH" >> $GITHUB_ENV
+          echo "PIPX_HOME=$HOME/.local/pipx" >> $GITHUB_ENV
+          echo "PIPX_BIN_DIR=$HOME/.local/bin" >> $GITHUB_ENV
+
+      - name: Install Base Dependencies
+        run: |
+          sudo apt-get install python3-venv pipx
+          pipx install hatch
+
+      - name: Run tests
+        run: |
+          hatch run test

lti_client_mock-0.0.1/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.coverage

lti_client_mock-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,7 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.20
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

lti_client_mock-0.0.1/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "python-envs.pythonProjects": [
+        {
+            "path": ".",
+            "envManager": "ms-python.python:system",
+            "packageManager": "ms-python.python:pip"
+        }
+    ]
+}

lti_client_mock-0.0.1/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026-present Mark Hall <mark.hall@work.room3b.eu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lti_client_mock-0.0.1/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.5
+Name: lti-client-mock
+Version: 0.0.1
+Project-URL: Documentation, https://github.com/Mark Hall/lti-client-mock#readme
+Project-URL: Issues, https://github.com/Mark Hall/lti-client-mock/issues
+Project-URL: Source, https://github.com/Mark Hall/lti-client-mock
+Author-email: Mark Hall <mark.hall@work.room3b.eu>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: fastapi
+Requires-Dist: itsdangerous
+Requires-Dist: pydantic
+Requires-Dist: pydantic-settings
+Requires-Dist: pylti1p3next
+Requires-Dist: python-multipart
+Description-Content-Type: text/markdown
+
+# lti-client-mock
+
+[![PyPI - Version](https://img.shields.io/pypi/v/lti-client-mock.svg)](https://pypi.org/project/lti-client-mock)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lti-client-mock.svg)](https://pypi.org/project/lti-client-mock)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install lti-client-mock
+```
+
+## License
+
+`lti-client-mock` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

lti_client_mock-0.0.1/README.md

@@ -0,0 +1,21 @@
+# lti-client-mock
+
+[![PyPI - Version](https://img.shields.io/pypi/v/lti-client-mock.svg)](https://pypi.org/project/lti-client-mock)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lti-client-mock.svg)](https://pypi.org/project/lti-client-mock)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install lti-client-mock
+```
+
+## License
+
+`lti-client-mock` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

lti_client_mock-0.0.1/lti_client_mock/__about__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2026-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""About this package."""
+
+__version__ = "0.0.1"

lti_client_mock-0.0.1/lti_client_mock/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""A mock LTI client server."""

lti_client_mock-0.0.1/lti_client_mock/server.py

@@ -0,0 +1,314 @@
+"""LTI Client (Tool) mock server."""
+
+import logging
+from datetime import datetime, timezone
+from secrets import token_hex
+from typing import Annotated
+
+from fastapi import Cookie, FastAPI
+from fastapi.exceptions import HTTPException
+from fastapi.requests import Request
+from fastapi.responses import RedirectResponse, Response
+from itsdangerous.exc import BadData
+from itsdangerous.serializer import Serializer
+from pylti1p3.cookie import CookieService as LTICookieService
+from pylti1p3.exception import LtiException, OIDCException
+from pylti1p3.message_launch import MessageLaunch as LTIMessageLaunch
+from pylti1p3.oidc_login import OIDCLogin as LTILogin
+from pylti1p3.request import Request as LTIRequest
+from pylti1p3.session import SessionService as LTISessionService
+from pylti1p3.tool_config.dict import ToolConfDict
+
+from lti_client_mock.settings import settings
+
+logger = logging.getLogger(__name__)
+app = FastAPI()
+lti_session_serializer = Serializer(token_hex(32), salt="lti-login")
+
+
+class FastAPILTIRequest(LTIRequest):
+    """Request wrapper for the LTI authentication processes."""
+
+    def __init__(
+        self: "FastAPILTIRequest",
+        request: Request,
+        parameters: dict,
+        clear_session: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """Create a new :class:`~container_launcher.server.handlers.lti.FastAPILTIRequest`.
+
+        :param request: The request handler for parameter and session access.
+        :type request: :class:`~fastapi.requests.Request`
+        :param parameters: The parameters sent with the request
+        :type params: dict
+        :param clear_session: Whether to clear the session first. Default: `False`
+        :type clear_session: bool
+        """
+        self._parameters = parameters
+        if "lti-session" in request.cookies and not clear_session:
+            try:
+                self._session = lti_session_serializer.loads(request.cookies["lti-session"])
+            except BadData as e:
+                logger.error(f"Invalid session data received: {e}")
+                self._session = {}
+        else:
+            self._session = {}
+
+    def get_param(self: "FastAPILTIRequest", key: str) -> str:
+        """Get the request parameter for the ``key``.
+
+        :param key: The key of the request parameter
+        :type key: str
+        :return: The value for the request parameter
+        :rtype: str | None
+        """
+        return self._parameters[key]
+
+    def is_secure(self: "FastAPILTIRequest") -> bool:
+        """Determine whether the request is secure.
+
+        Currently defaults to ``True``.
+        """
+        return True
+
+    @property
+    def session(self: "FastAPILTIRequest") -> dict:
+        """Get the session for the request.
+
+        :return: The current session.
+        :rtype: dict
+        """
+        return self._session
+
+
+class FastAPILTICookieService(LTICookieService):
+    """Cookie wrapper for the LTI authentication process."""
+
+    def __init__(self: "FastAPILTICookieService", request: Request) -> None:
+        """Create a new :class:`~container_launcher.server.handlers.lti.FastAPILTICookieService`.
+
+        :param request: The request to use for getting cookies.
+        :type request: :class:`~fastapi.requests.Request`
+        """
+        super().__init__()
+        self._request = request
+        self.cookies = {}
+
+    def set_cookie(self: "FastAPILTICookieService", name: str, value: str | int, exp: int | None = 3600) -> None:
+        """Set a cookie value.
+
+        :param name: The name of the cookie to set.
+        :type name: str
+        :param value: The value of the cookie to set.
+        :type value: str
+        :param expires: The number of seconds until the cookie expires.
+        :type expires: int
+        """
+        logger.debug(f"Set cookie {name} to {value}")
+        if exp is not None:
+            self.cookies[name] = {"value": str(value), "expires": exp}
+        else:
+            self.cookies[name] = {"value": str(value)}
+
+    def get_cookie(self: "FastAPILTICookieService", name: str) -> str | None:
+        """Get a cookie value.
+
+        :param name: The name of the cookie to get.
+        :type name: str
+        :return: The value of the cookie
+        :rtype: str
+        """
+        logger.debug(f"Fetch cookie {name}")
+        return self._request.cookies.get(name)
+
+
+class FastAPILTIRedirect:
+    """Redirection object required for the LTI authentication process."""
+
+    def __init__(
+        self: "FastAPILTIRedirect", request: "FastAPILTIRequest", cookie_service: "FastAPILTICookieService", url: str
+    ) -> None:
+        """Create a new :class:`~container_launcher.server.api.auth.lti.FastAPILTIRedirect`.
+
+        :param request: The request for accessing the session
+        :type request: :class:`~container_launcher.server.api.auth.lti.FastAPILTIRequest`
+        :param cookie_service: The service used to set cookies
+        :type cookie_service: :class:`~container_launcher.server.api.auth.lti.FastAPILTICookieService`
+        :param url: The URL to redirect to.
+        :type url: str
+        """
+        self._request = request
+        self._cookie_service = cookie_service
+        self._url = url
+
+    def do_redirect(self: "FastAPILTIRedirect") -> RedirectResponse:
+        """Perform the actual redirect."""
+        response = RedirectResponse(self._url)
+        for name, content in self._cookie_service.cookies.items():
+            response.set_cookie(
+                name,
+                content["value"],
+                expires=content["expires"],
+                samesite="lax",
+                secure=False,
+            )
+        session_data = lti_session_serializer.dumps(self._request.session)
+        response.set_cookie("lti-session", session_data, expires=300, samesite="lax", secure=False)
+        return response
+
+
+class FastAPILTILogin(LTILogin):
+    """LTI authentication process step 1: authentication."""
+
+    def __init__(
+        self: "FastAPILTILogin",
+        request: FastAPILTIRequest,
+        tool_config: ToolConfDict,
+        cookie_service: FastAPILTICookieService,
+    ) -> None:
+        """Create a new :class:`~container_launcher.server.api.auth.lti.FastAPILTILogin`.
+
+        :param request: The request containing the login initiation data.
+        :type request: :class:`~container_launcher.server.api.auth.lti.FastAPILTIRequest`
+        :param tool_config: The LTI tool configuration.
+        :type tool_config: :class:`~pylti1p3.tool_config.ToolConfigDict`
+        :param cookie_service: The service used to set cookies
+        :type cookie_service: :class:`~container_launcher.server.api.auth.lti.FastAPILTICookieService`
+        """
+        super().__init__(
+            request=request,
+            tool_config=tool_config,
+            session_service=LTISessionService(request),
+            cookie_service=cookie_service,
+        )
+
+    def get_redirect(self: "FastAPILTILogin", url: str) -> FastAPILTIRedirect:
+        """Get the authentication redirect.
+
+        :param url: The URL to redirect to.
+        :type url: str
+        :return: The redirection proxy.
+        :rtype: :class:`~container_launcher.server.api.auth.lti.FastAPILTIRedirect`
+        """
+        return FastAPILTIRedirect(self._request, self._cookie_service, url)
+
+
+class FastAPILTIMessageLaunch(LTIMessageLaunch):
+    """LTI authentication process step 2: launch."""
+
+    def __init__(
+        self: "FastAPILTIMessageLaunch",
+        request: FastAPILTIRequest,
+        tool_config: ToolConfDict,
+        cookie_service: FastAPILTICookieService,
+    ) -> None:
+        """Create a new :class:`~container_launcher.server.handlers.lti.FastAPILTIMessageLaunch`.
+
+        :param request: The request containing the launch data.
+        :type request: :class:`~container_launcher.server.api.auth.lti.FastAPILTIRequest`
+        :param tool_config: The LTI tool configuration.
+        :type tool_config: :class:`~pylti1p3.tool_config.ToolConfigDict`
+        :param cookie_service: The service used to get cookies
+        :type cookie_service: :class:`~container_launcher.server.api.auth.lti.FastAPILTICookieService`
+        """
+        super().__init__(
+            request=request,
+            tool_config=tool_config,
+            session_service=LTISessionService(request),
+            cookie_service=cookie_service,
+        )
+
+    def _get_request_param(self: "FastAPILTIMessageLaunch", key: str) -> str:
+        """Get a request parameter value.
+
+        :param key: The key of the request parameter to fetch.
+        :type key: str
+        :return: The request parameter value.
+        :rtype: str
+        """
+        return self._request.get_param(key)
+
+
+def login(request: Request, response: Response, parameters: dict) -> RedirectResponse:  # noqa: ARG001
+    """Start the LTI login process."""
+    logger.debug("Starting LTI login process")
+    oidc_request = FastAPILTIRequest(request, parameters, clear_session=True)
+    oidc_login = FastAPILTILogin(
+        request=oidc_request,
+        tool_config=ToolConfDict(settings.model_dump()["lti"]),
+        cookie_service=FastAPILTICookieService(request),
+    )
+    logger.debug("Redirecting to the LTI platform")
+    if "target_link_uri" in parameters:
+        return oidc_login.redirect(parameters["target_link_uri"])
+    else:
+        return oidc_login.redirect("")
+
+
+@app.post("/login", response_class=RedirectResponse)
+async def login_post(request: Request, response: Response) -> RedirectResponse:
+    """Start the LTI login process from a POST request."""
+    try:
+        return login(request, response, dict(await request.form()))
+    except OIDCException as e:
+        logger.error(e)
+        raise HTTPException(422, "No valid LTI login data found") from e
+
+
+@app.get("/login", response_class=RedirectResponse)
+def login_get(request: Request, response: Response) -> RedirectResponse:
+    """Start the LTI login process from a GET request."""
+    try:
+        return login(request, response, dict(request.query_params))
+    except OIDCException as e:
+        logger.error(e)
+        raise HTTPException(422, "No valid LTI login data found") from e
+
+
+async def launch(request: Request, response: Response, parameters: dict) -> str:
+    """Launch the LTI tool for the user."""
+    logger.debug("Starting the LTI launch process")
+    tool_config = ToolConfDict(settings.model_dump()["lti"])
+    oidc_request = FastAPILTIRequest(request, parameters)
+    message_launch = FastAPILTIMessageLaunch(
+        request=oidc_request,
+        tool_config=tool_config,
+        cookie_service=FastAPILTICookieService(request),
+    )
+    message_launch.set_jwt_verify_options({"verify_iat": False, "verify_aud": False})
+    logger.debug("LTI launch validated - logging in")
+    data = message_launch.get_launch_data()
+    logger.debug(data)
+    response.set_cookie(
+        "lti_client_mock_user", lti_session_serializer.dumps(data), max_age=None, secure=False, samesite="lax"
+    )
+    return "/success"
+
+
+@app.post("/launch", response_class=RedirectResponse, status_code=303)
+async def launch_post(request: Request, response: Response) -> str:
+    """Launch the LTI tool from a POST request."""
+    try:
+        return await launch(request, response, dict(await request.form()))
+    except LtiException as e:
+        logger.error(e)
+        logger.error(str(int(datetime.now(tz=timezone.utc).timestamp())))
+        raise HTTPException(422, "No valid LTI launch data found") from e
+
+
+@app.get("/launch", response_class=RedirectResponse, status_code=303)
+async def launch_get(request: Request, response: Response) -> str:
+    """Launch the LTI tool from a GET request."""
+    try:
+        return await launch(request, response, dict(request.query_params))
+    except LtiException as e:
+        logger.error(e)
+        logger.error(str(int(datetime.now(tz=timezone.utc).timestamp())))
+        raise HTTPException(422, "No valid LTI launch data found") from e
+
+
+@app.get("/success")
+def success(lti_client_mock_user: Annotated[str, Cookie()]):
+    """Show the successfull LTI login information."""
+    mock_user = lti_session_serializer.loads(lti_client_mock_user)
+    return mock_user

lti_client_mock-0.0.1/lti_client_mock/settings.py

@@ -0,0 +1,31 @@
+"""LTI client mock settings."""
+
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class LTIModel(BaseModel):
+    """Validation model for a single LTI configuration."""
+
+    client_id: str
+    auth_login_url: str
+    auth_token_url: str
+    key_set_url: str
+    deployment_ids: list[str]
+
+
+class Settings(BaseSettings):
+    """LTI provider mock settings."""
+
+    lti: dict[str, list[LTIModel]] = {}
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        env_prefix="LTI_CLIENT_MOCK__",
+        env_nested_delimiter="__",
+        extra="ignore",
+    )
+
+
+settings = Settings()

lti_client_mock-0.0.1/pyproject.toml

@@ -0,0 +1,163 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lti-client-mock"
+dynamic = ["version"]
+description = ''
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = []
+authors = [
+  { name = "Mark Hall", email = "mark.hall@work.room3b.eu" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "fastapi",
+  "itsdangerous",
+  "pydantic",
+  "pydantic-settings",
+  "pylti1p3next",
+  "python-multipart",
+]
+
+[project.urls]
+Documentation = "https://github.com/Mark Hall/lti-client-mock#readme"
+Issues = "https://github.com/Mark Hall/lti-client-mock/issues"
+Source = "https://github.com/Mark Hall/lti-client-mock"
+
+[tool.hatch.version]
+path = "lti_client_mock/__about__.py"
+
+[tool.hatch.envs.default]
+extra-dependencies = [
+  "beautifulsoup4",
+  "httpx2",
+  "lti-provider-mock",
+  "pytest",
+  "pytest-cov",
+  "ruff==0.15.20",
+  "uvicorn",
+]
+
+[tool.hatch.envs.default.scripts]
+server = "uvicorn --port 8485 --reload --reload-dir lti_client_mock --log-level debug --host=0.0.0.0 lti_client_mock.server:app"
+lti-provider = "uvicorn --port 8484 lti_provider_mock.server:app"
+
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = ["- coverage combine", "coverage report"]
+cov = ["test-cov", "cov-report"]
+
+ruff-check = "ruff check {args:.}"
+ruff-format = "ruff format {args:.}"
+ruff-style = ["ruff-format", "ruff-check"]
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:lti_client_mock tests}"
+
+[tool.coverage.run]
+source_pkgs = ["lti_client_mock", "tests"]
+branch = true
+parallel = true
+omit = [
+  "lti_client_mock/__about__.py",
+]
+
+[tool.coverage.paths]
+lti_client_mock = ["lti_client_mock", "*/lti-client-mock/lti_client_mock"]
+tests = ["tests", "*/lti-client-mock/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+skip_covered = true
+show_missing = true
+
+[tool.ruff]
+target-version = "py39"
+line-length = 120
+lint.select = [
+  "A",
+  "ARG",
+  "B",
+  "C",
+  "D",
+  "DTZ",
+  "E",
+  "EM",
+  "F",
+  "FBT",
+  "I",
+  "ICN",
+  "ISC",
+  "N",
+  "PLC",
+  "PLE",
+  "PLR",
+  "PLW",
+  "Q",
+  "RUF",
+  "S",
+  "T",
+  "TID",
+  "UP",
+  "W",
+  "YTT",
+]
+lint.ignore = [
+  # Allow non-abstract empty methods in abstract base classes
+  "B027",
+  # Allow boolean positional values in function calls, like `dict.get(... True)`
+  "FBT003",
+  # Ignore single-line concatenation
+  "ISC001",
+  # Ignore checks for possible passwords
+  "S105",
+  "S106",
+  "S107",
+  # Ignore complexity
+  "C901",
+  "PLR0911",
+  "PLR0912",
+  "PLR0913",
+  "PLR0915",
+  # Docstring settings
+  "D203",
+  "D211",
+  "D213",
+]
+lint.unfixable = [
+  # Don't touch unused imports
+  "F401",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["container_launcher"]
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**/*" = ["ARG001", "PLR2004", "S101", "TID252"]
+"dev/jupyterhub_config.py" = ["F821", "S104"]

lti_client_mock-0.0.1/tests/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""Test cases."""

lti_client_mock-0.0.1/tests/conftest.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: 2026-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""Test fixtures."""
+
+from threading import Thread
+from time import sleep
+
+import pytest
+import uvicorn
+from lti_provider_mock.server import app as lti_server_app
+
+from lti_client_mock.server import app as lti_client_app
+
+
+@pytest.fixture()
+def lti_client_mock():
+    """Run the LTI Client Mock for a single test."""
+    config = uvicorn.Config(lti_client_app, host="0.0.0.0", port=8485)  # noqa: S104
+    server = uvicorn.Server(config)
+
+    def run_server():
+        server.run()
+
+    thread = Thread(target=run_server)
+    thread.start()
+    yield server
+    server.should_exit = True
+    sleep(0.2)
+
+
+@pytest.fixture()
+def lti_provider_mock():
+    """Run the LTI Provider Mock for a single test."""
+    config = uvicorn.Config(lti_server_app, host="0.0.0.0", port=8484)  # noqa: S104
+    server = uvicorn.Server(config)
+
+    def run_server():
+        server.run()
+
+    thread = Thread(target=run_server)
+    thread.start()
+    yield server
+    server.should_exit = True
+    sleep(0.2)

lti_client_mock-0.0.1/tests/test_login.py

@@ -0,0 +1,92 @@
+# SPDX-FileCopyrightText: 2026-present Mark Hall <mark.hall@work.room3b.eu>
+#
+# SPDX-License-Identifier: MIT
+"""Test cases."""
+
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+from httpx2 import Client
+
+
+def serialise_form(form: Tag) -> dict:
+    """Serialise a HTML form parsed by BeautifulSoup into a dict for submission."""
+    data = {}
+    for element in form.children:
+        if isinstance(element, Tag) and element.name == "input":
+            data[element["name"]] = element["value"]
+    return data
+
+
+def test_login_flow_admin_user(lti_client_mock, lti_provider_mock):
+    """Test the login flow with the admin user."""
+    with Client(follow_redirects=True) as client:
+        client.post("http://localhost:8484/login", data={"userid": "1"})
+        response = client.post("http://localhost:8484/courses/1")
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        assert response.status_code == 200
+        userinfo = response.json()
+        assert userinfo["aud"] == "lti-provider-mock"
+        assert userinfo["family_name"] == "Admin"
+        assert userinfo["given_name"] == "The"
+        assert userinfo["sub"] == "1"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["id"] == "1"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["label"] == "Course 1"
+
+
+def test_login_flow_user_course_1(lti_client_mock, lti_provider_mock):
+    """Test the login flow with the a generic user and course 1."""
+    with Client(follow_redirects=True) as client:
+        client.post("http://localhost:8484/login", data={"userid": "2"})
+        response = client.post("http://localhost:8484/courses/1")
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        assert response.status_code == 200
+        userinfo = response.json()
+        assert userinfo["aud"] == "lti-provider-mock"
+        assert userinfo["family_name"] == "User"
+        assert userinfo["given_name"] == "A"
+        assert userinfo["sub"] == "2"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["id"] == "1"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["label"] == "Course 1"
+
+
+def test_login_flow_user_course_2(lti_client_mock, lti_provider_mock):
+    """Test the login flow with the a generic user and course 2."""
+    with Client(follow_redirects=True) as client:
+        client.post("http://localhost:8484/login", data={"userid": "2"})
+        response = client.post("http://localhost:8484/courses/2")
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        doc = BeautifulSoup(response.text, "html.parser")
+        form = doc.find("form")
+        url = str(form["action"])
+        data = serialise_form(form)
+        response = client.post(url, data=data)
+        assert response.status_code == 200
+        userinfo = response.json()
+        assert userinfo["aud"] == "lti-provider-mock"
+        assert userinfo["family_name"] == "User"
+        assert userinfo["given_name"] == "A"
+        assert userinfo["sub"] == "2"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["id"] == "2"
+        assert userinfo["https://purl.imsglobal.org/spec/lti/claim/context"]["label"] == "Course 2"