pytest-markdown-docs 0.9.1__tar.gz → 0.9.2__tar.gz

pytest_markdown_docs-0.9.1/README.md → pytest_markdown_docs-0.9.2/PKG-INFO

@@ -1,3 +1,19 @@
+Metadata-Version: 2.4
+Name: pytest-markdown-docs
+Version: 0.9.2
+Summary: Run markdown code fences through pytest
+Author: Modal Labs, Elias Freider
+Author-email: Elias Freider <elias@modal.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: markdown-it-py>=2.2.0,<4.0
+Requires-Dist: pytest>=7.0.0
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/modal-labs/pytest-markdown-docs
+Project-URL: Repository, https://github.com/modal-labs/pytest-markdown-docs
+Project-URL: Issue Tracker, https://github.com/modal-labs/pytest-markdown-docs/issues
+Description-Content-Type: text/markdown
+
 # Pytest Markdown Docs
 
 A plugin for [pytest](https://docs.pytest.org) that uses markdown code snippets from markdown files and docstrings as tests.
@@ -120,6 +136,29 @@ assert captured.out == "hello\n"
 
 As you can see above, the fixture value will be injected as a global. For `autouse=True` fixtures, the value is only injected as a global if it's explicitly added using a `fixture:<name>` marker.
 
+### Async Fixtures (pytest-asyncio)
+
+If you have [pytest-asyncio](https://pypi.org/project/pytest-asyncio/) installed, you can use async fixtures with your markdown tests. The async fixture will be executed and its resolved value will be injected into the test code:
+
+```python
+# conftest.py
+import pytest_asyncio
+
+@pytest_asyncio.fixture
+async def async_data():
+    # Simulate async data fetching
+    return {"status": "ok", "value": 42}
+```
+
+````markdown
+```python fixture:async_data
+assert async_data["status"] == "ok"
+assert async_data["value"] == 42
+```
+````
+
+Async fixtures can depend on other async fixtures, sync fixtures, or a mix of both. The fixture values are fully resolved before being passed to your markdown test code.
+
 ### Depending on previous snippets
 
 If you have multiple snippets following each other and want to keep the side

pytest_markdown_docs-0.9.1/PKG-INFO → pytest_markdown_docs-0.9.2/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.4
-Name: pytest-markdown-docs
-Version: 0.9.1
-Summary: Run markdown code fences through pytest
-Author: Modal Labs
-Author-email: Elias Freider <elias@modal.com>
-License-Expression: MIT
-License-File: LICENSE
-Requires-Python: >=3.9
-Requires-Dist: markdown-it-py<4.0,>=2.2.0
-Requires-Dist: pytest>=7.0.0
-Description-Content-Type: text/markdown
-
 # Pytest Markdown Docs
 
 A plugin for [pytest](https://docs.pytest.org) that uses markdown code snippets from markdown files and docstrings as tests.
@@ -133,6 +120,29 @@ assert captured.out == "hello\n"
 
 As you can see above, the fixture value will be injected as a global. For `autouse=True` fixtures, the value is only injected as a global if it's explicitly added using a `fixture:<name>` marker.
 
+### Async Fixtures (pytest-asyncio)
+
+If you have [pytest-asyncio](https://pypi.org/project/pytest-asyncio/) installed, you can use async fixtures with your markdown tests. The async fixture will be executed and its resolved value will be injected into the test code:
+
+```python
+# conftest.py
+import pytest_asyncio
+
+@pytest_asyncio.fixture
+async def async_data():
+    # Simulate async data fetching
+    return {"status": "ok", "value": 42}
+```
+
+````markdown
+```python fixture:async_data
+assert async_data["status"] == "ok"
+assert async_data["value"] == 42
+```
+````
+
+Async fixtures can depend on other async fixtures, sync fixtures, or a mix of both. The fixture values are fully resolved before being passed to your markdown test code.
+
 ### Depending on previous snippets
 
 If you have multiple snippets following each other and want to keep the side

{pytest_markdown_docs-0.9.1 → pytest_markdown_docs-0.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-markdown-docs"
-version = "0.9.1"
+version = "0.9.2"
 description = "Run markdown code fences through pytest"
 readme = "README.md"
 authors = [
@@ -8,26 +8,33 @@ authors = [
     { name = "Elias Freider", email = "elias@modal.com" } 
 ]
 license = "MIT"
+license-files = ["LICENSE"]
 requires-python = ">=3.9"
 dependencies = [
     "markdown-it-py>=2.2.0,<4.0",
     "pytest>=7.0.0",
 ]
-include = ["LICENSE"]
+
+[project.urls]
+Homepage = "https://github.com/modal-labs/pytest-markdown-docs"
+Repository = "https://github.com/modal-labs/pytest-markdown-docs"
+"Issue Tracker" = "https://github.com/modal-labs/pytest-markdown-docs/issues"
+
 
 [project.entry-points.pytest11]
 pytest_markdown_docs = "pytest_markdown_docs.plugin"
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["uv_build>=0.10.9,<0.11.0"]
+build-backend = "uv_build"
+
 
-[tool.uv]
-package=true
-dev-dependencies = [
+[dependency-groups]
+dev = [
     "mypy>=1.12.1",
     "pre-commit>=3.5.0",
-    "pytest~=8.1.0",
+    "pytest>=8.1.0",
+    "pytest-asyncio>=0.23.0",
     "ruff~=0.9.10",
-    "mdit-py-plugins~=0.4.2"
+    "mdit-py-plugins~=0.4.2",
 ]

{pytest_markdown_docs-0.9.1 → pytest_markdown_docs-0.9.2}/src/pytest_markdown_docs/_runners.py

@@ -1,5 +1,6 @@
 import abc
 import ast
+import inspect
 import traceback
 import typing
 from abc import abstractmethod
@@ -50,22 +51,29 @@ def register_runner(*, default: bool = False):
 
 @register_runner(default=True)
 class DefaultRunner(_Runner):
-    def runtest(self, test: FenceTestDefinition, args):
+    def runtest(self, test: FenceTestDefinition, args, *, asyncio_runner=None):
         try:
-            tree = ast.parse(test.source, filename=test.source_path)
-        except SyntaxError:
-            raise
-
-        try:
-            # if we don't compile the code, it seems we get name lookup errors
-            # for functions etc. when doing cross-calls across inline functions
             compiled = compile(
-                tree, filename=test.source_path, mode="exec", dont_inherit=True
+                test.source,
+                filename=test.source_path,
+                mode="exec",
+                flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,
+                dont_inherit=True,
             )
         except SyntaxError:
             raise
 
-        exec(compiled, args)
+        if compiled.co_flags & inspect.CO_COROUTINE:
+            if asyncio_runner is None:
+                raise RuntimeError(
+                    "Top-level async code in markdown code blocks is not natively supported.\n"
+                    "You need pytest-asyncio>=1.1.0 to run async code blocks:\n"
+                    "  pip install 'pytest-asyncio>=1.1.0'"
+                )
+            coro = eval(compiled, args)
+            asyncio_runner.run(coro)
+        else:
+            exec(compiled, args)
 
     def repr_failure(
         self,

{pytest_markdown_docs-0.9.1 → pytest_markdown_docs-0.9.2}/src/pytest_markdown_docs/plugin.py

@@ -52,6 +52,14 @@ def get_docstring_start_line(obj) -> typing.Optional[int]:
     return None  # Docstring not found in source
 
 
+def _get_asyncio_runner(fixture_request):
+    """Try to fetch pytest-asyncio's event loop runner for shared-loop execution."""
+    try:
+        return fixture_request.getfixturevalue("_function_scoped_runner")
+    except Exception:
+        return None
+
+
 class MarkdownInlinePythonItem(pytest.Item):
     def __init__(
         self,
@@ -109,8 +117,17 @@ class MarkdownInlinePythonItem(pytest.Item):
             try:
                 # this ensures that pytest's stdout/stderr capture works during the test:
                 capman = self.config.pluginmanager.getplugin("capturemanager")
+                asyncio_runner = _get_asyncio_runner(self.fixture_request)
                 with capman.global_and_fixture_disabled():
-                    self.runner.runtest(self.test_definition, all_globals)
+                    try:
+                        self.runner.runtest(
+                            self.test_definition,
+                            all_globals,
+                            asyncio_runner=asyncio_runner,
+                        )
+                    except TypeError:
+                        # Custom runner doesn't accept asyncio_runner kwarg
+                        self.runner.runtest(self.test_definition, all_globals)
 
                 # Success - test passed
                 if attempt > 0:
@@ -282,8 +299,33 @@ def extract_options_from_mdx_comment(comment: str) -> typing.Set[str]:
     return set(option.strip() for option in comment.split(" ") if option)
 
 
+def _preprocess_async_fixtures_if_available(collector: pytest.Collector) -> None:
+    """
+    If pytest-asyncio is installed, trigger its async fixture preprocessing.
+
+    pytest-asyncio preprocesses async fixtures during collection, but only for
+    pytest.Module and pytest.Class collectors. We need to trigger this manually
+    for our markdown collectors so that async fixtures work correctly.
+    """
+    try:
+        from pytest_asyncio.plugin import (  # type: ignore
+            _preprocess_async_fixtures,
+            _HOLDER,
+        )
+
+        _preprocess_async_fixtures(collector, _HOLDER)
+    except ImportError:
+        # pytest-asyncio is not installed, or using a newer version that
+        # doesn't require these imports
+        pass
+
+
 class MarkdownDocstringCodeModule(pytest.Module):
     def collect(self):
+        # Trigger pytest-asyncio's async fixture preprocessing if available
+        # (needed for pytest-asyncio 0.23.x; 1.x uses pytest_fixture_setup hook instead)
+        _preprocess_async_fixtures_if_available(self)
+
         if pytest.version_tuple >= (8, 1, 0):
             # consider_namespace_packages is a required keyword argument in pytest 8.1.0
             module = import_path(
@@ -361,6 +403,10 @@ class MarkdownDocstringCodeModule(pytest.Module):
 
 class MarkdownTextFile(pytest.File):
     def collect(self):
+        # Trigger pytest-asyncio's async fixture preprocessing if available
+        # (needed for pytest-asyncio 0.23.x; 1.x uses pytest_fixture_setup hook instead)
+        _preprocess_async_fixtures_if_available(self)
+
         markdown_content = self.path.read_text("utf8")
         fence_syntax = FenceSyntax(self.config.option.markdowndocs_syntax)
 

pytest_markdown_docs-0.9.1/.github/pull_request_template.md

@@ -1,5 +0,0 @@
-<!--
-  ✍️ Write a short summary of this change, then request review from a recent contributor.
--->
-
-**Issue:** https://github.com/modal-labs/pytest-markdown-docs/issues/XX or N/A

pytest_markdown_docs-0.9.1/.github/workflows/check.yml

@@ -1,27 +0,0 @@
-name: ruff & mypy
-on: push
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
-      - name: Install uv
-        uses: astral-sh/setup-uv@caf0cab7a618c569241d31dcd442f54681755d39 # v3
-
-      - name: Install Python (3.11)
-        uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
-        with:
-          python-version: 3.11
-
-      - name: Install the project
-        run: uv sync --all-extras --dev --no-install-project
-
-      - name: Ruff check
-        run: uv run ruff check --diff
-
-      - name: Ruff format
-        run: uv run ruff format --diff
-
-      - name: Mypy
-        run: uv run mypy .

pytest_markdown_docs-0.9.1/.github/workflows/ci.yml

@@ -1,31 +0,0 @@
-name: Test
-on: push
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@caf0cab7a618c569241d31dcd442f54681755d39 # v3
-
-      - name: Install Python ${{ matrix.python-version }}
-        uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install the project
-        run: uv sync --all-extras --dev
-
-      - name: Run tests with pytest
-        run: uv run pytest
-
-      - name: Downgrade to pytest 7
-        run: uv pip install "pytest<8"
-
-      - name: Run tests with pytest 7
-        run: uv run pytest

pytest_markdown_docs-0.9.1/.github/workflows/codeql.yml

@@ -1,74 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-  schedule:
-    - cron: '42 12 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'python' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@b8d3b6e8af63cde30bdc382c0bc28114f4346c88 # v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@b8d3b6e8af63cde30bdc382c0bc28114f4346c88 # v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@b8d3b6e8af63cde30bdc382c0bc28114f4346c88 # v2
-      with:
-        category: "/language:${{matrix.language}}"

pytest_markdown_docs-0.9.1/.gitignore

@@ -1,129 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/

pytest_markdown_docs-0.9.1/.pre-commit-config.yaml

@@ -1,8 +0,0 @@
-repos:
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.9.10"
-    hooks:
-      - id: ruff
-        # Autofix, and respect `exclude` and `extend-exclude` settings.
-        args: [--fix, --exit-non-zero-on-fix]
-      - id: ruff-format

pytest_markdown_docs-0.9.1/Makefile

@@ -1,8 +0,0 @@
-build:
-	uv build
-
-clean:
-	rm -rf dist
-
-publish: clean build
-	uv publish

pytest_markdown_docs-0.9.1/tests/conftest.py

@@ -1,10 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-pytest_plugins = ["pytester"]
-
-
-@pytest.fixture()
-def support_dir():
-    return Path(__file__).parent / "support"

pytest_markdown_docs-0.9.1/tests/plugin_test.py

@@ -1,723 +0,0 @@
-import re
-
-from _pytest.pytester import LineMatcher
-
-import pytest_markdown_docs  # hack: used for storing a side effect in one of the tests
-
-
-def test_docstring_markdown(testdir):
-    testdir.makeconftest(
-        """
-        def pytest_markdown_docs_globals():
-            return {"a": "hello"}
-    """
-    )
-    testdir.makepyfile(
-        """
-        def simple():
-            \"\"\"
-            ```python
-            import pytest_markdown_docs
-            pytest_markdown_docs.side_effect = "hello"
-            ```
-
-            ```
-            not a python block
-            ```
-            \"\"\"
-
-
-        class Parent:
-            def using_global(self):
-                \"\"\"
-                ```python
-                assert a + " world" == "hello world"
-                ```
-                \"\"\"
-
-        def failing():
-            \"\"\"
-            ```python
-            assert False
-            ```
-            \"\"\"
-
-        def error():
-            \"\"\"
-            ```python
-            raise Exception("oops")
-            ```
-            \"\"\"
-    """
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=2, failed=2)
-    assert (
-        getattr(pytest_markdown_docs, "side_effect", None) == "hello"
-    )  # hack to make sure the test actually does something
-
-
-def test_markdown_text_file(testdir):
-    testdir.makeconftest(
-        """
-        def pytest_markdown_docs_globals():
-            return {"a": "hello"}
-    """
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        ```python
-        assert a + " world" == "hello world"
-        ```
-
-        ```python
-        assert False
-        ```
-
-        ```python
-        **@ # this is a syntax error
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1, failed=2)
-
-
-def test_continuation(testdir):
-    testdir.makefile(
-        ".md",
-        """
-        ```python
-        b = "hello"
-        ```
-
-        ```python continuation
-        assert b + " world" == "hello world"
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=2)
-
-
-def test_traceback(testdir):
-    testdir.makefile(
-        ".md",
-        """
-        yada yada yada
-
-        ```python
-        def foo():
-            raise Exception("doh")
-
-        def bar():
-            foo()
-
-        foo()
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=0, failed=1)
-
-    # we check the traceback vs a regex pattern since the file paths can change
-    expected_output_pattern = r"""
-Error in code block:
-     ```
- 4   def foo\(\):
- 5       raise Exception\("doh"\)
- 6
- 7   def bar\(\):
- 8       foo\(\)
- 9
-10   foo\(\)
-     ```
-Traceback \(most recent call last\):
-  File ".*/test_traceback.md", line 10, in <module>
-    foo\(\)
-  File ".*/test_traceback.md", line 5, in foo
-    raise Exception\("doh"\)
-Exception: doh
-""".strip()
-    pytest_output = "\n".join(line.rstrip() for line in result.outlines).strip()
-    assert re.search(expected_output_pattern, pytest_output) is not None, (
-        "Output traceback doesn't match expected value"
-    )
-
-
-def test_autouse_fixtures(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-
-@pytest.fixture(autouse=True)
-def initialize():
-    import pytest_markdown_docs
-    pytest_markdown_docs.bump = getattr(pytest_markdown_docs, "bump", 0) + 1
-    yield
-    pytest_markdown_docs.bump -= 1
-"""
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        ```python
-        import pytest_markdown_docs
-        assert pytest_markdown_docs.bump == 1
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_specific_fixtures(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-
-@pytest.fixture()
-def initialize_specific():
-    import pytest_markdown_docs
-    pytest_markdown_docs.bump = getattr(pytest_markdown_docs, "bump", 0) + 1
-    yield "foobar"
-    pytest_markdown_docs.bump -= 1
-"""
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        \"\"\"
-        ```python fixture:initialize_specific
-        import pytest_markdown_docs
-        assert pytest_markdown_docs.bump == 1
-        assert initialize_specific == "foobar"
-        ```
-        \"\"\"
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_non_existing_fixture_error(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-
-@pytest.fixture()
-def foo():
-    pass
-"""
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        \"\"\"
-        ```python fixture:bar
-        ```
-        \"\"\"
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    assert "fixture 'bar' not found" in result.stdout.str()
-    result.assert_outcomes(errors=1)
-
-
-def test_fixture_overriding_global(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-
-def pytest_markdown_docs_globals():
-    return {
-        "some_global": "foo"
-    }
-
-@pytest.fixture()
-def some_global():
-    return "bar"
-"""
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        \"\"\"
-        ```python
-        assert some_global == "foo"
-        ```
-
-        ```python fixture:some_global
-        assert some_global == "bar"
-        ```
-        \"\"\"
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=2)
-
-
-def test_continuation_mdx_comment(testdir):
-    testdir.makefile(
-        ".mdx",
-        """
-        ```python
-        b = "hello"
-        ```
-        {/* pmd-metadata: continuation */}
-        ```python
-        assert b + " world" == "hello world"
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=2)
-
-
-def test_specific_fixture_mdx_comment(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-@pytest.fixture()
-def initialize_specific():
-    import pytest_markdown_docs
-    pytest_markdown_docs.bump = getattr(pytest_markdown_docs, "bump", 0) + 1
-    yield "foobar"
-    pytest_markdown_docs.bump -= 1
-"""
-    )
-
-    testdir.makefile(
-        ".mdx",
-        """
-        {/* pmd-metadata: fixture:initialize_specific */}
-        ```python
-        import pytest_markdown_docs
-        assert pytest_markdown_docs.bump == 1
-        assert initialize_specific == "foobar"
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_multiple_fixtures_mdx_comment(testdir):
-    testdir.makeconftest(
-        """
-import pytest
-@pytest.fixture()
-def initialize_specific():
-    import pytest_markdown_docs
-    pytest_markdown_docs.bump = getattr(pytest_markdown_docs, "bump", 0) + 1
-    yield "foobar"
-    pytest_markdown_docs.bump -= 1
-
-@pytest.fixture
-def another_fixture():
-    return "hello"
-"""
-    )
-
-    testdir.makefile(
-        ".mdx",
-        """
-        {/* pmd-metadata: fixture:initialize_specific fixture:another_fixture */}
-        ```python
-        import pytest_markdown_docs
-        assert pytest_markdown_docs.bump == 1
-        assert initialize_specific == "foobar"
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_notest_mdx_comment(testdir):
-    testdir.makefile(
-        ".mdx",
-        """
-        {/* pmd-metadata: notest */}
-        ```python
-        assert True
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=0)
-
-
-def test_superfences_format_markdown(testdir):
-    testdir.makefile(
-        ".md",
-        """
-        ```python
-        b = "hello"
-        ```
-
-        ```{.python continuation}
-        assert b + " world" == "hello world"
-        ```
-
-        # the lang may not be the first element
-        ```{other_option .python .other-class continuation}
-        assert b + " world" == "hello world"
-        ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs", "--markdown-docs-syntax=superfences")
-    result.assert_outcomes(passed=3)
-
-
-def test_superfences_format_docstring(testdir):
-    testdir.makepyfile(
-        """
-        def simple():
-            \"\"\"
-            ```python
-            b = "hello"
-            ```
-
-            ```{.python continuation}
-            assert b + " world" == "hello world"
-            ```
-            \"\"\"
-        """
-    )
-    result = testdir.runpytest("--markdown-docs", "--markdown-docs-syntax=superfences")
-    result.assert_outcomes(passed=2)
-
-
-def test_error_origin_after_docstring_traceback(testdir, support_dir):
-    sample_file = support_dir / "docstring_error_after.py"
-    testdir.makepyfile(**{sample_file.stem: sample_file.read_text()})
-    result = testdir.runpytest("-v", "--markdown-docs")
-
-    data: LineMatcher = result.stdout
-    data.re_match_lines(
-        [
-            r"Traceback \(most recent call last\):",
-            r'\s*File ".*/docstring_error_after.py", line 5, in <module>',
-            r"\s*docstring_error_after.error_after\(\)",
-            r'\s*File ".*/docstring_error_after.py", line 11, in error_after',
-            r'\s*raise Exception\("bar"\)',
-            r"\s*Exception: bar",
-        ],
-        consecutive=True,
-    )
-
-
-def test_error_origin_before_docstring_traceback(testdir, support_dir):
-    sample_file = support_dir / "docstring_error_before.py"
-    testdir.makepyfile(**{sample_file.stem: sample_file.read_text()})
-    result = testdir.runpytest("-v", "--markdown-docs")
-
-    data: LineMatcher = result.stdout
-    data.re_match_lines(
-        [
-            r"Traceback \(most recent call last\):",
-            r'\s*File ".*/docstring_error_before.py", line 9, in <module>',
-            r"\s*docstring_error_before.error_before\(\)",
-            r'\s*File ".*/docstring_error_before.py", line 2, in error_before',
-            r'\s*raise Exception\("foo"\)',
-            r"\s*Exception: foo",
-        ],
-        consecutive=True,
-    )
-
-
-def test_custom_runner(testdir):
-    testdir.makeconftest(
-        """
-        import pytest_markdown_docs._runners
-        
-        @pytest_markdown_docs._runners.register_runner()
-        class LinesAreAllFoo(pytest_markdown_docs._runners.DefaultRunner):
-            def runtest(self, test, args):
-                lines = test.source.strip().split("\\n")
-                for line in lines:
-                    assert line == "foo"
-    """
-    )
-    testdir.makefile(
-        ".md",
-        """
-        ```python runner:LinesAreAllFoo
-        foo
-        foo
-        ```
-        
-        ```python runner:LinesAreAllFoo
-        foo
-        bar
-        ```
-    """,
-    )
-
-    result = testdir.runpytest("-v", "--markdown-docs")
-    result.assert_outcomes(passed=1, failed=1)
-    result.stdout.re_match_lines(
-        [
-            r".*\[CodeFence#1\]\[line:1\].*PASSED.*",
-            r".*\[CodeFence#2\]\[line:6\].*FAILED.*",
-        ],
-        consecutive=True,
-    )
-
-
-def test_admonition_markdown_text_file(testdir):
-    testdir.makeconftest(
-        """
-        def pytest_markdown_docs_globals():
-            return {"a": "hello"}
-
-        def pytest_markdown_docs_markdown_it():
-            import markdown_it
-            from mdit_py_plugins.admon import admon_plugin
-
-            mi = markdown_it.MarkdownIt(config="commonmark")
-            mi.use(admon_plugin)
-            return mi
-    """
-    )
-
-    testdir.makefile(
-        ".md",
-        """
-        ??? quote
-
-            ```python
-            assert a + " world" == "hello world"
-            ```
-
-        !!! info
-            ```python
-            assert False
-            ```
-
-        ???+ note
-            ```python
-            **@ # this is a syntax error
-            ```
-    """,
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1, failed=2)
-
-
-def test_retry_eventually_succeeds(testdir):
-    """Test that a flaky test succeeds after retrying."""
-    testdir.makepyfile(
-        conftest="""
-attempt_counter = {}
-"""
-    )
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:3
-import conftest
-key = "test_1"
-conftest.attempt_counter[key] = conftest.attempt_counter.get(key, 0) + 1
-assert conftest.attempt_counter[key] >= 2  # Fails first time, passes on retry
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_retry_exhausted(testdir):
-    """Test that a test fails after all retry attempts are exhausted."""
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:2
-assert False  # Always fails
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(failed=1)
-
-
-def test_retry_with_fixture(testdir):
-    """Test that fixtures are not re-run between retries."""
-    testdir.makepyfile(
-        conftest="""
-import pytest
-
-fixture_call_count = 0
-
-@pytest.fixture
-def counting_fixture():
-    global fixture_call_count
-    fixture_call_count += 1
-    return fixture_call_count
-
-attempt_counter = {}
-"""
-    )
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:3 fixture:counting_fixture
-import conftest
-key = "test_2"
-conftest.attempt_counter[key] = conftest.attempt_counter.get(key, 0) + 1
-
-# Fixture should only be called once (value should stay 1)
-assert counting_fixture == 1
-
-# Fail on first attempt, pass on second
-assert conftest.attempt_counter[key] >= 2
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_retry_with_continuation(testdir):
-    """Test that retry works with continuation blocks."""
-    testdir.makepyfile(
-        conftest="""
-attempt_counter = {}
-"""
-    )
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python
-a = "hello"
-```
-
-```python retry:2 continuation
-import conftest
-key = "test_3"
-conftest.attempt_counter[key] = conftest.attempt_counter.get(key, 0) + 1
-
-# Variable 'a' from previous block should be available
-assert a + " world" == "hello world"
-
-# Fail on first attempt, pass on second
-assert conftest.attempt_counter[key] >= 2
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=2)
-
-
-def test_retry_invalid_negative(testdir):
-    """Test that negative retry counts raise an error."""
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:-1
-assert True
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines(["*Invalid retry count*non-negative integer*"])
-
-
-def test_retry_invalid_non_numeric(testdir):
-    """Test that non-numeric retry counts raise an error."""
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:abc
-assert True
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines(["*Invalid retry count*non-negative integer*"])
-
-
-def test_retry_multiple_values_error(testdir):
-    """Test that multiple retry values raise an error."""
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:2 retry:3
-assert True
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(errors=1)
-    result.stdout.fnmatch_lines(["*Multiple retry counts are not supported*"])
-
-
-def test_retry_zero(testdir):
-    """Test that retry:0 behaves the same as no retry."""
-    testdir.makefile(
-        ".md",
-        test_file="""
-```python retry:0
-assert False
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(failed=1)
-
-
-def test_retry_mdx_comment(testdir):
-    """Test that retry works with MDX comment metadata."""
-    testdir.makepyfile(
-        conftest="""
-attempt_counter = {}
-"""
-    )
-    testdir.makefile(
-        ".mdx",
-        test_file="""
-{/* pmd-metadata: retry:3 */}
-```python
-import conftest
-key = "test_4"
-conftest.attempt_counter[key] = conftest.attempt_counter.get(key, 0) + 1
-assert conftest.attempt_counter[key] >= 2
-```
-""",
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)
-
-
-def test_retry_with_docstring(testdir):
-    """Test that retry works in Python docstrings."""
-    testdir.makepyfile(
-        conftest="""
-attempt_counter = {}
-"""
-    )
-    testdir.makepyfile(
-        test_module="""
-def my_function():
-    \"\"\"
-    ```python retry:3
-    import conftest
-    key = "test_5"
-    conftest.attempt_counter[key] = conftest.attempt_counter.get(key, 0) + 1
-    assert conftest.attempt_counter[key] >= 2
-    ```
-    \"\"\"
-    pass
-"""
-    )
-    result = testdir.runpytest("--markdown-docs")
-    result.assert_outcomes(passed=1)

pytest_markdown_docs-0.9.1/tests/support/docstring_error_after.py

@@ -1,11 +0,0 @@
-def func():
-    """
-    ```python
-    import docstring_error_after
-    docstring_error_after.error_after()
-    ```
-    """
-
-
-def error_after():
-    raise Exception("bar")

pytest_markdown_docs-0.9.1/tests/support/docstring_error_before.py

@@ -1,11 +0,0 @@
-def error_before():
-    raise Exception("foo")
-
-
-def func():
-    """
-    ```python
-    import docstring_error_before
-    docstring_error_before.error_before()
-    ```
-    """