django-markdown-view 0.0.6__py3-none-any.whl

markdown_view/loading.py

@@ -0,0 +1,57 @@
+"""
+Locate and read a ``markdown_view`` ``file_name`` value's underlying
+source file without compiling its raw, pre-Markdown-conversion contents
+as a Django template.
+
+Both `MarkdownView` and `registry.py` need to resolve a `file_name` (e.g.
+``"users/README.md"``) to an actual file on disk, using whatever loaders
+`MARKDOWN_VIEW_LOADERS` configures. The obvious way to do that with
+Django's own `Engine`/`Loader` API is `engine.get_template(file_name)` --
+but `Loader.get_template()` doesn't just locate the file: it also
+constructs a `django.template.base.Template` from its *raw* contents,
+which eagerly compiles and validates that source as Django template
+syntax immediately, before any Markdown conversion has happened. A `.md`
+file whose raw text contains literal template-tag-shaped syntax anywhere
+at all -- inside a fenced code block documenting Django itself, for
+instance, or in an inline-code span -- would then raise
+`TemplateSyntaxError` merely from being *loaded*, well before
+`MarkdownView` gets a chance to convert it to HTML, and therefore before
+`escaping.escape_unsafe_template_syntax()` (which only ever sees the
+already-converted HTML) gets any chance to make that literal syntax safe.
+
+`load_markdown_source()` instead walks the engine's configured loaders and
+origins directly, reading each candidate file's raw contents (via each
+loader's own `get_contents()`, the same plain, uncompiled read
+`Loader.get_template()` itself uses before wrapping the result in a
+`Template`) without ever constructing a `Template` from them.
+"""
+import os
+
+from django.template import TemplateDoesNotExist
+
+
+def load_markdown_source(file_name, engine):
+    """
+    Resolve `file_name` to its underlying source file using `engine`'s
+    configured template loaders, and return its raw text -- without
+    compiling that text as a Django template.
+
+    :param file_name: A `file_name` value, as passed to
+        `MarkdownView.as_view(file_name=...)`.
+    :param engine: The `django.template.Engine` whose loaders should be
+        used to resolve `file_name`.
+    :return: A `(source_text, source_path)` tuple, where `source_path` is
+        the absolute, normalized filesystem path the source was read from.
+    :raises TemplateDoesNotExist: If no configured loader can locate
+        `file_name`.
+    """
+    tried = []
+    for loader in engine.template_loaders:
+        for origin in loader.get_template_sources(file_name):
+            try:
+                contents = loader.get_contents(origin)
+            except TemplateDoesNotExist:
+                tried.append((origin, "Source does not exist"))
+                continue
+            return contents, os.path.normpath(origin.name)
+    raise TemplateDoesNotExist(file_name, tried=tried)

markdown_view/markdown_extensions.py

@@ -0,0 +1,19 @@
+import re
+
+from markdown.treeprocessors import Treeprocessor
+from markdown.extensions import Extension
+
+
+class InlineImageProcessor(Treeprocessor):
+    def run(self, root):
+        for element in root.iter("img"):
+            src_orig = element.attrib.get('src', '')
+            src_re = re.sub(r"[/\\]*static[/\\]*", "", src_orig)
+            src = "{{% static '{}' %}}".format(src_re)
+            element.attrib["src"] = src
+            element.attrib["class"] = "img-fluid"
+
+
+class ImageExtension(Extension):
+    def extendMarkdown(self, md):
+        md.treeprocessors.register(InlineImageProcessor(md), 'inlineimageprocessor', 15)

markdown_view/registry.py

@@ -0,0 +1,387 @@
+"""
+Registry mapping ``MarkdownView`` (and subclass) ``file_name`` values to the
+concrete URLs that serve them.
+
+Markdown source files commonly link to other markdown files using plain,
+filesystem-relative links (e.g. ``[See also](../README-cron.md)``), exactly
+as they would on GitHub or in a local editor. When such a file is rendered
+as an HTML page instead of viewed as a raw file, that relative link no
+longer resolves to anything meaningful in the browser -- the rendered page
+lives at whatever URL its own view was routed to, not at the file's
+location on disk.
+
+This module lets ``MarkdownView`` automatically discover, for any given
+target ``.md`` file, whether some URL pattern in the project serves that
+file via a ``MarkdownView`` (or subclass), and if so, resolve to that URL
+instead of leaving the raw relative path in place.
+
+This is intentionally best-effort: routes behind a required URL argument,
+or wrapped by a decorator that doesn't preserve the underlying view's
+``view_class``/``view_initkwargs`` attributes, are silently skipped. A link
+that can't be resolved to a known route is left exactly as markdown would
+otherwise have rendered it, unless a fallback root is configured via
+``MARKDOWN_VIEW_UNRESOLVED_LINK_ROOT`` (see ``rewrite_markdown_links()``),
+in which case such links -- including relative links to files other than
+``.md``, such as repository-relative source links -- are resolved against
+that root instead.
+"""
+import logging
+import os
+import re
+from urllib.parse import urljoin, urlsplit, urlunsplit
+
+from django.conf import settings
+from django.core.signals import setting_changed
+from django.template import Engine, TemplateDoesNotExist
+from django.urls import NoReverseMatch, URLResolver, get_resolver, reverse
+
+from markdown_view.constants import (
+    DEFAULT_MARKDOWN_VIEW_LOADERS, DEFAULT_MARKDOWN_VIEW_UNRESOLVED_LINK_ROOT,
+)
+from markdown_view.loading import load_markdown_source
+
+logger = logging.getLogger(__name__)
+
+# Cached {id(resolver): {absolute file path: full reverse name}} registries.
+# Keyed by the resolver's identity (Django itself caches `get_resolver()` per
+# urlconf, so this naturally rebuilds if `ROOT_URLCONF`/the active urlconf
+# ever changes, e.g. under `override_settings` in tests). Note that the
+# *reverse name* is cached here, not the result of calling `reverse()` on
+# it -- `reverse()` can depend on request/runtime context (e.g. the active
+# language under `i18n_patterns()`, or the active script prefix), so it must
+# be called fresh every time a link is actually rewritten.
+#
+# This cache key does *not* otherwise account for `MARKDOWN_VIEW_LOADERS`,
+# since a route's file resolution normally never changes while its
+# resolver/urlconf stays the same -- so instead we listen for
+# `MARKDOWN_VIEW_LOADERS` changing (e.g. via `override_settings` in tests)
+# below and explicitly clear the cache when it does.
+_registry_cache = {}
+
+
+def _on_setting_changed(*, setting, **kwargs):
+    """
+    Invalidate the cached URL registry whenever `MARKDOWN_VIEW_LOADERS`
+    changes (e.g. via `override_settings` in tests), since the registry's
+    `source_path` keys depend on how that setting resolves `file_name`
+    values to files on disk, and merely rebuilding on urlconf/resolver
+    identity change (as `get_markdown_view_url_registry()` does) wouldn't
+    otherwise catch a loader-only change.
+    """
+    if setting == "MARKDOWN_VIEW_LOADERS":
+        clear_markdown_view_url_registry_cache()
+
+
+setting_changed.connect(_on_setting_changed)
+
+
+def _build_engine():
+    """
+    Return a new `Engine` configured with the same template loaders
+    `MarkdownView` itself uses, so relative `file_name` values resolve
+    identically here and at render time. Built fresh (not cached at module
+    scope) so it always reflects the current `MARKDOWN_VIEW_LOADERS` setting,
+    e.g. under `override_settings` in tests.
+    """
+    return Engine(
+        loaders=getattr(
+            settings, "MARKDOWN_VIEW_LOADERS", DEFAULT_MARKDOWN_VIEW_LOADERS
+        )
+    )
+
+
+def resolve_markdown_source_path(file_name, engine=None):
+    """
+    Resolve a markdown_view `file_name` to the absolute filesystem path of
+    its underlying source file, using the same template-loader resolution
+    `MarkdownView` uses to actually load and render it.
+
+    Deliberately does not use `engine.get_template(...)`: that constructs
+    a `Template` from the file's raw, pre-Markdown-conversion contents,
+    which eagerly compiles/validates that raw text as Django template
+    syntax and can raise `TemplateSyntaxError` for a `.md` file whose raw
+    source happens to contain literal template-tag-shaped text anywhere.
+    `load_markdown_source()` resolves the same file without compiling it.
+
+    :param file_name: A `file_name` value, as passed to
+        `MarkdownView.as_view(file_name=...)`.
+    :param engine: An optional `django.template.Engine` to resolve
+        `file_name` with. Built via `_build_engine()` if not provided.
+    :return: An absolute, normalized filesystem path, or `None` if it
+        cannot be resolved (e.g. no matching file exists).
+    """
+    if engine is None:
+        engine = _build_engine()
+    try:
+        _, source_path = load_markdown_source(file_name, engine)
+    except TemplateDoesNotExist:
+        return None
+    return source_path
+
+
+def _iter_markdown_view_routes(resolver, namespace_parts=()):
+    """
+    Recursively walk a URLResolver's patterns, yielding
+    `(file_name, full_reverse_name)` for every leaf pattern whose view is a
+    `MarkdownView` (or subclass) constructed with a `file_name` kwarg.
+
+    :param resolver: A `django.urls.URLResolver` (typically the project's
+        root resolver, from `django.urls.get_resolver()`).
+    :param namespace_parts: Namespace segments accumulated from ancestor
+        `include()` calls, used to build the fully-qualified reverse name.
+    """
+    # Local import to avoid a hard import-time dependency between this
+    # module and `views.py` (which doesn't need to import this module at
+    # module load time).
+    from markdown_view.views import MarkdownView
+
+    for pattern in resolver.url_patterns:
+        if isinstance(pattern, URLResolver):
+            # A nested `include()` -- recurse into it, extending the
+            # namespace path if this include() was itself namespaced.
+            child_namespace = namespace_parts
+            if pattern.namespace:
+                child_namespace = namespace_parts + (pattern.namespace,)
+            yield from _iter_markdown_view_routes(pattern, child_namespace)
+            continue
+
+        # Leaf pattern (an actual URL, not a nested urlconf). Only
+        # `as_view()`-based class-based views expose `view_class`/
+        # `view_initkwargs` on their callback -- function views and
+        # views wrapped by decorators that don't forward these
+        # attributes will simply have `view_class=None` and get skipped
+        # below.
+        callback = getattr(pattern, "callback", None)
+        view_class = getattr(callback, "view_class", None)
+        if not (isinstance(view_class, type) and issubclass(view_class, MarkdownView)):
+            continue
+
+        file_name = getattr(callback, "view_initkwargs", {}).get("file_name")
+        if not file_name or not pattern.name:
+            # No `file_name`, or an unnamed route we can't `reverse()`.
+            continue
+
+        # Build the fully-qualified name (e.g. "users:support:readme")
+        # needed to `reverse()` this route later, since `pattern.name`
+        # alone is only unique within its own urlconf.
+        full_name = ":".join((*namespace_parts, pattern.name))
+        yield file_name, full_name
+
+
+def build_markdown_view_url_registry(resolver=None):
+    """
+    Build a `{absolute source file path: full reverse name}` mapping for
+    every registered `MarkdownView` (or subclass) route in the project, by
+    walking the resolved root URLconf.
+
+    Note that this stores the *reverse name* for each route, not the result
+    of calling `reverse()` on it -- `reverse()`'s result can depend on
+    request/runtime context (e.g. the active language under
+    `i18n_patterns()`, or the active script prefix), so it must be called
+    fresh at the point a link is actually rewritten, not cached here.
+
+    :param resolver: A `django.urls.URLResolver` to walk. Defaults to
+        `django.urls.get_resolver()` (the project's root resolver).
+    :return: dict mapping each route's absolute source file path to the
+        full reverse name (e.g. `"users:support:readme"`) that serves it.
+    """
+    if resolver is None:
+        resolver = get_resolver()
+
+    engine = _build_engine()
+    registry = {}
+    for file_name, full_name in _iter_markdown_view_routes(resolver):
+        # Map the route to the file it serves by resolving `file_name`
+        # (e.g. "users/README.md") through the same loader MarkdownView
+        # itself uses, so the key here matches the `source_path` that
+        # `rewrite_markdown_links()` will later look up against it.
+        source_path = resolve_markdown_source_path(file_name, engine=engine)
+        if source_path is None:
+            logger.debug(
+                "markdown_view: route %r references file_name %r, which "
+                "could not be resolved to a source file; skipping.",
+                full_name, file_name,
+            )
+            continue
+        try:
+            # Routes behind a required URL argument (e.g.
+            # "<int:pk>/readme/") can't be reversed without knowing that
+            # argument's value, so they're simply not linkable targets.
+            # The result is only used here to confirm reversibility --
+            # it's discarded rather than cached, since `reverse()` must be
+            # called fresh (with the active request's language/script
+            # prefix, etc.) whenever a link is actually rewritten.
+            reverse(full_name)
+        except NoReverseMatch:
+            logger.debug(
+                "markdown_view: could not reverse %r for file_name %r; "
+                "skipping (likely behind a required URL argument).",
+                full_name, file_name,
+            )
+            continue
+        if source_path in registry:
+            # The same source file is served by more than one route. There's
+            # no inherently correct answer here, so we make the choice
+            # explicit: the first route encountered wins, and later aliases
+            # are logged rather than silently overriding it -- adding a
+            # later alias shouldn't unexpectedly change all of a file's
+            # internal links to the new alias.
+            logger.debug(
+                "markdown_view: file_name %r is already routed to %r; "
+                "ignoring additional route %r for the same file.",
+                file_name, registry[source_path], full_name,
+            )
+            continue
+        registry[source_path] = full_name
+    return registry
+
+
+def get_markdown_view_url_registry(force_refresh=False):
+    """
+    Return the (cached) `{absolute source file path: full reverse name}`
+    registry for the currently active URLconf, building it on first access.
+
+    :param force_refresh: Rebuild the registry even if a cached copy exists.
+    :return: dict mapping each route's absolute source file path to the
+        full reverse name that serves it.
+    """
+    resolver = get_resolver()
+    # `get_resolver()` is itself cached per-urlconf by Django, so keying
+    # on its identity means this registry naturally rebuilds if the
+    # active urlconf ever changes (e.g. `ROOT_URLCONF` swapped via
+    # `override_settings` in tests) without needing to track that
+    # explicitly.
+    cache_key = id(resolver)
+    if force_refresh or cache_key not in _registry_cache:
+        _registry_cache[cache_key] = build_markdown_view_url_registry(resolver)
+    return _registry_cache[cache_key]
+
+
+def clear_markdown_view_url_registry_cache():
+    """Clear all cached URL registries. Primarily useful in tests."""
+    _registry_cache.clear()
+
+
+# Matches an `<a href="...">` opening tag, capturing the text before the
+# href value (group 1), the href value itself (group 2), and the closing
+# quote (group 3), so `_replace()` below can substitute just the middle
+# group back into the original tag without disturbing anything else on
+# the `<a>` tag (other attributes, casing, etc.).
+_HREF_RE = re.compile(r'(<a\b[^>]*\bhref=")([^"]*)(")', re.IGNORECASE)
+
+
+def rewrite_markdown_links(html, source_path, registry=None):
+    """
+    Rewrite `<a href="...">` targets in rendered markdown HTML that point
+    at other markdown source files -- via a plain, filesystem-relative
+    link resolved relative to `source_path`'s directory -- to the actual
+    routed URL of the `MarkdownView` serving that file, if one is
+    registered.
+
+    When a relative link doesn't resolve to a registered route (e.g. it
+    targets a file that isn't served by any `MarkdownView`, or isn't a
+    `.md` file at all -- such as a repository-relative link to source
+    code), it's instead resolved against the optional
+    `MARKDOWN_VIEW_UNRESOLVED_LINK_ROOT` setting, if configured. This lets
+    links like ``[helper](src/example/module.py)`` -- which resolve
+    correctly when browsing the source repository, but not when rendered
+    as a page served at its own unrelated URL -- point somewhere useful
+    (e.g. the same file, viewed on the project's SCM web interface).
+    Registered-route resolution always takes precedence over this
+    fallback. With no fallback root configured, such links are left
+    exactly as markdown would otherwise have rendered them.
+
+    Links that are absolute (have a scheme or network location, start
+    with `/`, or are fragment-only) are always left untouched. Any query
+    string or `#fragment` on the original link is preserved on the
+    rewritten URL, and `./`/`../` relative-path segments are resolved
+    correctly (rather than through simple string concatenation) when
+    applying the fallback root.
+
+    :param html: Rendered HTML markup, already converted from Markdown.
+    :param source_path: Absolute filesystem path of the `.md` file `html`
+        was rendered from; used to resolve relative link targets.
+    :param registry: An optional pre-built `{absolute path: full reverse
+        name}` registry. Built via `get_markdown_view_url_registry()` if
+        not provided.
+    :return: The HTML with resolvable internal links rewritten.
+    """
+    if registry is None:
+        registry = get_markdown_view_url_registry()
+    # Relative links in the source `.md` file are resolved the same way a
+    # browser or file manager would: relative to the directory the *source
+    # file* lives in, not relative to the URL the rendered page happens to
+    # be served at.
+    source_dir = os.path.dirname(source_path)
+    unresolved_link_root = getattr(
+        settings,
+        "MARKDOWN_VIEW_UNRESOLVED_LINK_ROOT",
+        DEFAULT_MARKDOWN_VIEW_UNRESOLVED_LINK_ROOT,
+    )
+
+    def _replace(match):
+        prefix, href, suffix = match.groups()
+        # Use real URL parsing rather than string tests, so query strings
+        # and fragments on otherwise-relative links (e.g.
+        # `guide.md?format=print#section`) are recognized and preserved,
+        # while links with a scheme (`mailto:`, `tel:`, `custom-scheme:`,
+        # `https://...`) or netloc, or that are site-root-relative, are
+        # correctly left alone.
+        parts = urlsplit(href)
+        if parts.scheme or parts.netloc or parts.path.startswith("/"):
+            # Already absolute -- nothing for us to resolve, leave as-is.
+            return match.group(0)
+        if not parts.path:
+            # Fragment-only (e.g. "#section") or query-only link -- no
+            # relative target to resolve at all.
+            return match.group(0)
+
+        resolved_url = None
+        if parts.path.lower().endswith(".md"):
+            # Resolve the relative path exactly as the browser would if
+            # this were a raw file link, then see if some route serves
+            # that exact file.
+            resolved_path = os.path.normpath(
+                os.path.join(source_dir, parts.path)
+            )
+            full_name = registry.get(resolved_path)
+            if full_name is None:
+                logger.debug(
+                    "markdown_view: no registered route for linked file "
+                    "%r (resolved from %r while rendering %r).",
+                    resolved_path, href, source_path,
+                )
+            else:
+                try:
+                    # Resolved fresh on every call (rather than cached),
+                    # since `reverse()`'s result can depend on
+                    # request/runtime context -- e.g. the currently
+                    # active language under `i18n_patterns()`, or the
+                    # active script prefix -- not just the URLconf.
+                    resolved_url = reverse(full_name)
+                except NoReverseMatch:
+                    # The registry is stale relative to the active
+                    # URLconf (e.g. it changed since the registry was
+                    # built).
+                    logger.debug(
+                        "markdown_view: could not reverse %r for linked "
+                        "file %r while rendering %r; falling back.",
+                        full_name, resolved_path, source_path,
+                    )
+
+        if resolved_url is None:
+            if not unresolved_link_root:
+                # No registered route, and no fallback root configured --
+                # leave the link exactly as Markdown would otherwise have
+                # rendered it, rather than producing a broken URL of our
+                # own.
+                return match.group(0)
+            # `urljoin()` (rather than plain string concatenation)
+            # correctly resolves `./` and `../` path segments in the
+            # original relative link against the fallback root.
+            resolved_url = urljoin(unresolved_link_root, parts.path)
+
+        new_href = urlunsplit(("", "", resolved_url, parts.query, parts.fragment))
+        return f"{prefix}{new_href}{suffix}"
+
+    return _HREF_RE.sub(_replace, html)

markdown_view/templates/markdown_view/markdown.html

@@ -0,0 +1,28 @@
+{% if use_highlight_js %}
+	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/styles/a11y-light.min.css" integrity="sha512-PW96n2amVglidqEDLPUdjJ0zByhT20poSqWJYZRutR6CP2QH58k96WmorqNnC4QXnosNeqMJM8FR/93isIifDQ==" crossorigin="anonymous" />
+	<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/highlight.min.js" integrity="sha512-lnOllyZZlRk/gQIyjS3+h+LUy54uyM4aGq2zbGc82KTvBlp/fodSpdh/pywPztpU9zUqHcJr+jP+a1zLa9oCJw==" crossorigin="anonymous"></script>
+{% endif %}
+
+{% comment %}{{ page_title|safe }}{% endcomment %}
+
+{% if use_toc %}
+    <section id="markdown_view_toc">
+        <h3>Table of Contents</h3>
+        {{ markdown_toc }}
+    </section>
+{% endif %}
+
+<section id="markdown_view_content">
+	{{ markdown_content }}
+</section>
+
+{% if use_highlight_js %}
+    <script>
+        hljs.initHighlightingOnLoad();
+        $(document).ready(function(){
+            $('.md-content div.toc ul').attr("class", "cta-links");
+            $('.md-content div.toc ul li a').attr("class", "default-fa");
+            $('.md-content table').attr("class", "table table-bordered table-hover table-striped table-mobile tablesorter tablesorter-default");
+        });
+    </script>
+{% endif %}

markdown_view/tests/fixtures/loaders_a/readme.md

@@ -0,0 +1,4 @@
+# Fixture used by markdown_view.tests.test_registry to prove that the
+# markdown_view URL registry rebuilds when MARKDOWN_VIEW_LOADERS changes,
+# even without ROOT_URLCONF/the resolver identity changing.
+# "loaders_a" version.

markdown_view/tests/fixtures/loaders_b/readme.md

@@ -0,0 +1,4 @@
+# Fixture used by markdown_view.tests.test_registry to prove that the
+# markdown_view URL registry rebuilds when MARKDOWN_VIEW_LOADERS changes,
+# even without ROOT_URLCONF/the resolver identity changing.
+# "loaders_b" version.

markdown_view/tests/settings/coveralls_settings.py

@@ -0,0 +1,74 @@
+"""
+Django settings used to run this project's test suite (see ``manage.py`` and
+``tox.ini``, which invoke ``manage.py test`` / ``coverage run manage.py
+test`` against
+``DJANGO_SETTINGS_MODULE=markdown_view.tests.settings.coveralls_settings``).
+"""
+import os
+
+# The `markdown_view/tests/` directory, used below to locate fixtures.
+TESTS_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# The repository root. `markdown_view.loaders.MarkdownLoader` falls back to
+# this (via `MarkdownLoader.get_dirs()`) when `MARKDOWN_VIEW_BASE_DIR` isn't
+# set, so this is also exercised directly by `test_loaders.py`.
+BASE_DIR = os.path.dirname(os.path.dirname(TESTS_DIR))
+
+SECRET_KEY = "not-a-secret-only-used-to-run-tests"
+DEBUG = True
+ALLOWED_HOSTS = ["*"]
+
+INSTALLED_APPS = [
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.staticfiles",
+    "markdown_view",
+    "markdown_view.tests.testapp",
+]
+
+MIDDLEWARE = [
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.middleware.common.CommonMiddleware",
+]
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+ROOT_URLCONF = "markdown_view.tests.urls"
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+            ],
+        },
+    },
+]
+
+# The default `MARKDOWN_VIEW_LOADERS` (`markdown_view.loaders.MarkdownLoader`)
+# is used for the vast majority of the suite -- it discovers fixtures under
+# `markdown_view/tests/testapp/` via `INSTALLED_APPS`, exactly as it would in
+# a real project. `markdown_view.tests.test_registry`'s loader-cache
+# invalidation tests override this per-test (via `override_settings`) to
+# point at `fixtures/loaders_a`/`fixtures/loaders_b` instead.
+
+AUTH_PASSWORD_VALIDATORS = []
+
+LOGIN_URL = "/accounts/login/"
+
+STATIC_URL = "/static/"
+
+USE_TZ = True
+
+DEFAULT_AUTO_FIELD = "django.db.models.AutoField"

markdown_view/tests/test_checks.py

@@ -0,0 +1,38 @@
+from django.core.checks import Tags, run_checks
+from django.test import SimpleTestCase, override_settings
+
+from markdown_view.checks import markdown_view_check
+
+
+class MarkdownViewCheckTests(SimpleTestCase):
+    def test_returns_empty_list_for_valid_settings(self):
+        # markdown_view/tests/settings/coveralls_settings.py doesn't define
+        # any of the optional MARKDOWN_VIEW_* settings, so there's nothing
+        # to flag.
+        self.assertEqual(markdown_view_check(app_configs=[]), [])
+
+
+class MarkdownViewCheckRegistrationTests(SimpleTestCase):
+    """
+    Confirms `markdown_view_check` is actually *wired up* through Django's
+    system-check framework (registered against `Tags.security` in
+    `MarkdownViewConfig.ready()`, see `markdown_view/apps.py`), not just
+    that the function itself behaves correctly in isolation.
+    """
+
+    def test_run_checks_surfaces_invalid_setting_via_registered_check(self):
+        with override_settings(MARKDOWN_VIEW_TEMPLATE_USE_TOC="not-a-bool"):
+            errors = run_checks(tags=[Tags.security])
+
+        self.assertTrue(
+            any(error.id == "markdown_view.E001" for error in errors),
+            "Expected django.core.checks.run_checks() to surface "
+            "markdown_view.E001 for an invalid MARKDOWN_VIEW_* setting; "
+            "got: %r" % (errors,),
+        )
+
+    def test_run_checks_reports_no_markdown_view_errors_for_valid_settings(self):
+        errors = run_checks(tags=[Tags.security])
+        self.assertFalse(
+            any(error.id == "markdown_view.E001" for error in errors)
+        )