pytest-codeblock 0.5.4__tar.gz → 0.5.6__tar.gz

{pytest_codeblock-0.5.4/src/pytest_codeblock.egg-info → pytest_codeblock-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-codeblock
-Version: 0.5.4
+Version: 0.5.6
 Summary: Pytest plugin to collect and test code blocks in reStructuredText and Markdown files.
 Author-email: Artur Barseghyan <artur.barseghyan@gmail.com>
 Maintainer-email: Artur Barseghyan <artur.barseghyan@gmail.com>
@@ -146,8 +146,8 @@ Prerequisites
 Documentation
 =============
 - Documentation is available on `Read the Docs`_.
-- For `reStructuredText`_, see a dedicated `reStructuredText docs`_.
-- For `Markdown`_, see a dedicated `Markdown docs`_.
+- For `reStructuredText`, see a dedicated `reStructuredText docs`_.
+- For `Markdown`, see a dedicated `Markdown docs`_.
 - Both `reStructuredText docs`_ and `Markdown docs`_ have extensive
   documentation on `pytest`_ markers and corresponding ``conftest.py`` hooks.
 - For guidelines on contributing check the `Contributor guidelines`_.

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/README.rst

@@ -83,8 +83,8 @@ Prerequisites
 Documentation
 =============
 - Documentation is available on `Read the Docs`_.
-- For `reStructuredText`_, see a dedicated `reStructuredText docs`_.
-- For `Markdown`_, see a dedicated `Markdown docs`_.
+- For `reStructuredText`, see a dedicated `reStructuredText docs`_.
+- For `Markdown`, see a dedicated `Markdown docs`_.
 - Both `reStructuredText docs`_ and `Markdown docs`_ have extensive
   documentation on `pytest`_ markers and corresponding ``conftest.py`` hooks.
 - For guidelines on contributing check the `Contributor guidelines`_.

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "pytest-codeblock"
 description = "Pytest plugin to collect and test code blocks in reStructuredText and Markdown files."
 readme = "README.rst"
-version = "0.5.4"
+version = "0.5.6"
 requires-python = ">=3.10"
 dependencies = [
     "pytest",

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/src/pytest_codeblock/__init__.py

@@ -6,7 +6,7 @@ from .md import MarkdownFile
 from .rst import RSTFile
 
 __title__ = "pytest-codeblock"
-__version__ = "0.5.4"
+__version__ = "0.5.6"
 __author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
 __copyright__ = "2025-2026 Artur Barseghyan"
 __license__ = "MIT"

pytest_codeblock-0.5.6/src/pytest_codeblock/collector.py

@@ -0,0 +1,104 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025-2026 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "CodeSnippet",
+    "group_snippets",
+)
+
+
+@dataclass
+class CodeSnippet:
+    """Data container for an extracted code snippet."""
+    code: str  # The code content
+    line: int  # Starting line number in the source
+    name: Optional[str] = None  # Identifier for grouping (None if anonymous)
+    marks: list[str] = field(default_factory=list)
+    # Collected pytest marks (e.g. ['django_db']), parsed from doc comments
+    fixtures: list[str] = field(default_factory=list)
+    # Collected pytest fixtures (e.g. ['tmp_path']), parsed from doc comments
+    group: Optional[str] = None
+    # Set by ``continue:`` directives; names the group this snippet belongs to
+
+
+def group_snippets(snippets: list[CodeSnippet]) -> list[CodeSnippet]:
+    """
+    Combine snippets that share a group key, using one of two modes:
+
+    - **Merge mode** (default): snippets sharing the same name (no ``group``
+      set, or nameless/same-name continuations) are concatenated into a single
+      test, accumulating marks and fixtures. This is the original behaviour.
+    - **Incremental mode**: when every continuation snippet (``group`` set) in
+      a group also carries its own distinct name, emit one test per snippet.
+      Each test's code is the cumulative concatenation of all preceding
+      snippets plus itself, so each step is exercised in isolation.
+
+    Unnamed snippets receive unique auto-keys so they are never merged.
+    """
+    # Pass 1: bucket each snippet by its group key, preserving insertion order.
+    buckets: dict[str, list[CodeSnippet]] = {}
+    order: list[str] = []
+    anon_count = 0
+
+    for sn in snippets:
+        if sn.group:
+            key = sn.group
+        elif sn.name:
+            key = sn.name
+        else:
+            anon_count += 1
+            key = f"codeblock{anon_count}"
+
+        if key not in buckets:
+            buckets[key] = []
+            order.append(key)
+        buckets[key].append(sn)
+
+    # Pass 2: emit merged or incremental snippets per bucket.
+    combined: list[CodeSnippet] = []
+
+    for key in order:
+        members = buckets[key]
+        continuations = [sn for sn in members if sn.group]
+        # Incremental only when every continuation has a distinct own name.
+        incremental = continuations and all(
+            sn.name and sn.name != key for sn in continuations
+        )
+
+        if incremental:
+            acc_code = ""
+            acc_marks: list[str] = []
+            acc_fixtures: list[str] = []
+            for sn in members:
+                acc_code = acc_code + "\n" + sn.code if acc_code else sn.code
+                acc_marks.extend(sn.marks)
+                acc_fixtures.extend(sn.fixtures)
+                combined.append(CodeSnippet(
+                    name=sn.name,
+                    code=acc_code,
+                    line=sn.line,
+                    marks=list(acc_marks),
+                    fixtures=list(acc_fixtures),
+                ))
+        else:
+            # Merge mode (original behaviour).
+            first = members[0]
+            merged_marks = list(first.marks)
+            merged_fixtures = list(first.fixtures)
+            merged_code = first.code
+            for sn in members[1:]:
+                merged_code += "\n" + sn.code
+                merged_marks.extend(sn.marks)
+                merged_fixtures.extend(sn.fixtures)
+            combined.append(CodeSnippet(
+                name=first.name,
+                code=merged_code,
+                line=first.line,
+                marks=merged_marks,
+                fixtures=merged_fixtures,
+            ))
+
+    return combined

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/src/pytest_codeblock/md.py

@@ -128,18 +128,18 @@ def parse_markdown(text: str) -> list[CodeSnippet]:
                 # end of block
                 in_block = False
                 code_text = "\n".join(code_buffer)
+                snippet_group = None
                 # continue overrides snippet_name for grouping
                 if pending_continue:
-                    final_name = pending_continue
+                    snippet_group = pending_continue
                     pending_continue = None
-                else:
-                    final_name = snippet_name
                 snippets.append(CodeSnippet(
-                    name=final_name,
+                    name=snippet_name,
                     code=code_text,
                     line=start_line,
                     marks=pending_marks.copy(),
                     fixtures=pending_fixtures.copy(),
+                    group=snippet_group,
                 ))
                 # reset pending marks after collecting
                 pending_marks = [CODEBLOCK_MARK]  # Reset to default

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/src/pytest_codeblock/rst.py

@@ -204,12 +204,12 @@ def parse_rst(text: str, base_dir: Path) -> list[CodeSnippet]:
                         k += 1
                     else:
                         break
+                sn_group = None
                 # Decide snippet name: continue overrides name_val/pending_name
                 if pending_continue:
-                    sn_name = pending_continue
+                    sn_group = pending_continue
                     pending_continue = None
-                else:
-                    sn_name = name_val or pending_name
+                sn_name = name_val or pending_name
                 sn_marks = pending_marks.copy()
                 sn_fixtures = pending_fixtures.copy()
                 pending_name = None
@@ -222,6 +222,7 @@ def parse_rst(text: str, base_dir: Path) -> list[CodeSnippet]:
                     line=j + 1,
                     marks=sn_marks,
                     fixtures=sn_fixtures,
+                    group=sn_group,
                 ))
 
                 i = k
@@ -235,11 +236,11 @@ def parse_rst(text: str, base_dir: Path) -> list[CodeSnippet]:
         # --------------------------------------------------------------------
         if line.rstrip().endswith("::") and pending_name:
             # Similar override logic
+            sn_group = None
             if pending_continue:
-                sn_name = pending_continue
+                sn_group = pending_continue
                 pending_continue = None
-            else:
-                sn_name = pending_name
+            sn_name = pending_name
             sn_marks = pending_marks.copy()
             sn_fixtures = pending_fixtures.copy()
             pending_name = None
@@ -273,6 +274,7 @@ def parse_rst(text: str, base_dir: Path) -> list[CodeSnippet]:
                 line=j + 1,
                 marks=sn_marks,
                 fixtures=sn_fixtures,
+                group=sn_group,
             ))
             i = k
             continue

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/src/pytest_codeblock/tests/test_integration.py

@@ -368,6 +368,38 @@ assert y == 2
 
     # -------------------------------------------------------------------------
 
+    def test_parse_incremental_continuation(self):
+        """Named continuation blocks produce N cumulative tests."""
+        text = """
+```python name=test_something
+something = 1
+```
+
+<!-- continue: test_something -->
+```python name=test_something_2
+something = "a"
+```
+
+<!-- continue: test_something -->
+```python name=test_something_3
+something = Exception("")
+```
+"""
+        snippets = parse_markdown(text)
+        grouped = group_snippets(snippets)
+        assert len(grouped) == 3
+        assert grouped[0].name == "test_something"
+        assert grouped[0].code.strip() == "something = 1"
+        assert grouped[1].name == "test_something_2"
+        assert "something = 1" in grouped[1].code
+        assert 'something = "a"' in grouped[1].code
+        assert grouped[2].name == "test_something_3"
+        assert "something = 1" in grouped[2].code
+        assert 'something = "a"' in grouped[2].code
+        assert 'something = Exception("")' in grouped[2].code
+
+    # -------------------------------------------------------------------------
+
     def test_parse_codeblock_name_directive(self):
         """Test the <!-- codeblock-name: name --> directive."""
         text = """
@@ -844,6 +876,8 @@ assert x == 1
         result.assert_outcomes(passed=1)
         assert "test_basic" in result.stdout.str()
 
+    # -------------------------------------------------------------------------
+
     def test_collect_with_fixture(self, pytester_subprocess):
         """Test that fixtures are properly injected."""
         pytester_subprocess.makefile(
@@ -858,6 +892,8 @@ assert tmp_path.exists()
         result = pytester_subprocess.runpytest("-v", "-p", "no:django")
         result.assert_outcomes(passed=1)
 
+    # -------------------------------------------------------------------------
+
     def test_collect_async_code(self, pytester_subprocess):
         """Test that async code is automatically wrapped."""
         pytester_subprocess.makefile(
@@ -872,6 +908,8 @@ await asyncio.sleep(0)
         result = pytester_subprocess.runpytest("-v", "-p", "no:django")
         result.assert_outcomes(passed=1)
 
+    # -------------------------------------------------------------------------
+
     def test_syntax_error_reporting(self, pytester_subprocess):
         """Test that syntax errors in snippets are properly reported."""
         pytester_subprocess.makefile(
@@ -890,6 +928,8 @@ def broken(:
             or "syntax" in result.stdout.str().lower()
         )
 
+    # -------------------------------------------------------------------------
+
     def test_runtime_error_reporting(self, pytester_subprocess):
         """Test that runtime errors in snippets are properly reported."""
         pytester_subprocess.makefile(
@@ -904,6 +944,40 @@ raise ValueError("intentional error")
         result.assert_outcomes(failed=1)
         assert "ValueError" in result.stdout.str()
 
+    # -------------------------------------------------------------------------
+
+    def test_incremental_continue_collects_separate_tests(
+        self, pytester_subprocess
+    ):
+        """Each named continuation block becomes its own cumulative test."""
+        pytester_subprocess.makefile(
+            ".md",
+            test_incremental="""
+```python name=test_step_one
+something = 1
+assert something == 1
+```
+
+<!-- continue: test_step_one -->
+```python name=test_step_two
+something = "a"
+assert something == "a"
+```
+
+<!-- continue: test_step_one -->
+```python name=test_step_three
+something = Exception("")
+assert isinstance(something, Exception)
+```
+""",
+        )
+        result = pytester_subprocess.runpytest("-v", "-p", "no:django")
+        result.assert_outcomes(passed=3)
+        stdout = result.stdout.str()
+        assert "test_step_one" in stdout
+        assert "test_step_two" in stdout
+        assert "test_step_three" in stdout
+
 
 # -----------------------------------------------------------------------------
 # Test RSTFile.collect() method
@@ -931,6 +1005,8 @@ Test File
         result.assert_outcomes(passed=1)
         assert "test_rst_basic" in result.stdout.str()
 
+    # -------------------------------------------------------------------------
+
     def test_collect_with_fixture(self, pytester_subprocess):
         """Test that RST fixtures are properly injected."""
         pytester_subprocess.makefile(
@@ -947,6 +1023,8 @@ Test File
         result = pytester_subprocess.runpytest("-v", "-p", "no:django")
         result.assert_outcomes(passed=1)
 
+    # -------------------------------------------------------------------------
+
     def test_collect_async_code(self, pytester_subprocess):
         """Test that RST async code is automatically wrapped."""
         pytester_subprocess.makefile(
@@ -962,6 +1040,8 @@ Test File
         result = pytester_subprocess.runpytest("-v", "-p", "no:django")
         result.assert_outcomes(passed=1)
 
+    # -------------------------------------------------------------------------
+
     def test_syntax_error_reporting(self, pytester_subprocess):
         """Test that syntax errors in RST snippets are reported."""
         pytester_subprocess.makefile(
@@ -1001,6 +1081,8 @@ assert True
         )
         assert "test_md_hook" in result.stdout.str()
 
+    # -------------------------------------------------------------------------
+
     def test_hook_dispatches_rst(self, pytester_subprocess):
         """Test that .rst files are dispatched to RSTFile."""
         pytester_subprocess.makefile(
@@ -1017,6 +1099,8 @@ assert True
         )
         assert "test_rst_hook" in result.stdout.str()
 
+    # -------------------------------------------------------------------------
+
     def test_hook_ignores_other_files(self, pytester_subprocess):
         """Test that non-.md/.rst files are ignored."""
         pytester_subprocess.makefile(".txt", notes="Some notes")

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6}/src/pytest_codeblock/tests/test_pytest_codeblock.py

@@ -36,6 +36,21 @@ def test_group_snippets_merges_named():
     assert "m" in cs.marks
 
 
+def test_group_snippets_incremental():
+    # Continuation snippets with distinct own names produce N cumulative tests.
+    sn1 = CodeSnippet(name="test_root", code="a=1", line=1)
+    sn2 = CodeSnippet(name="test_step2", code="b=2", line=5, group="test_root")
+    sn3 = CodeSnippet(name="test_step3", code="c=3", line=9, group="test_root")
+    combined = group_snippets([sn1, sn2, sn3])
+    assert len(combined) == 3
+    assert combined[0].name == "test_root"
+    assert combined[1].name == "test_step2"
+    assert combined[2].name == "test_step3"
+    assert combined[0].code == "a=1"
+    assert combined[1].code == "a=1\nb=2"
+    assert combined[2].code == "a=1\nb=2\nc=3"
+
+
 def test_group_snippets_different_names():
     # Snippets with different names are not grouped
     sn1 = CodeSnippet(name="foo", code="x=1", line=1)

pytest_codeblock-0.5.6/src/pytest_codeblock/tests/test_pytestrun_marker.py

@@ -0,0 +1,315 @@
+"""
+Tests for the `pytestrun` marker functionality.
+
+When a code block is marked with ``pytestrun``, the plugin writes the block to
+a temporary file and executes it via pytest as a subprocess, so that
+``Test*`` classes, ``test_*`` functions, fixtures, markers, and
+setup/teardown all behave exactly as they would in a normal pytest run.
+"""
+import textwrap
+
+import pytest
+
+from ..constants import CODEBLOCK_MARK, PYTESTRUN_MARK
+from ..md import parse_markdown
+from ..pytestrun import run_pytest_style_code
+from ..rst import parse_rst
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025-2026 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "TestPytestrunMarkParsing",
+    "TestRunPytestStyleCode",
+)
+
+
+# ============================================================================
+# Test that pytestrun mark is parsed correctly from MD and RST sources
+# ============================================================================
+class TestPytestrunMarkParsing:
+    """Test that the pytestrun mark is captured during parsing."""
+
+    def test_md_pytestmark_pytestrun_captured(self):
+        """The pytestrun mark is present after parsing a marked MD block."""
+        text = textwrap.dedent("""\
+            <!-- pytestmark: pytestrun -->
+            ```python name=test_pytestrun_parse
+            def test_ok():
+                assert True
+            ```
+        """)
+        snippets = parse_markdown(text)
+        assert len(snippets) == 1
+        assert PYTESTRUN_MARK in snippets[0].marks
+
+    def test_md_both_codeblock_and_pytestrun_marks(self):
+        """Both codeblock and pytestrun marks are present simultaneously."""
+        text = textwrap.dedent("""\
+            <!-- pytestmark: pytestrun -->
+            ```python name=test_marks_coexist
+            def test_x():
+                pass
+            ```
+        """)
+        snippets = parse_markdown(text)
+        assert CODEBLOCK_MARK in snippets[0].marks
+        assert PYTESTRUN_MARK in snippets[0].marks
+
+    def test_md_no_pytestrun_mark_by_default(self):
+        """A plain code block does NOT carry the pytestrun mark."""
+        text = textwrap.dedent("""\
+            ```python name=test_plain
+            x = 1
+            ```
+        """)
+        snippets = parse_markdown(text)
+        assert PYTESTRUN_MARK not in snippets[0].marks
+
+    def test_rst_pytestmark_pytestrun_captured(self, tmp_path):
+        """The pytestrun mark is present after parsing a marked RST block."""
+        rst = textwrap.dedent("""\
+            .. pytestmark: pytestrun
+
+            .. code-block:: python
+               :name: test_pytestrun_rst
+
+               def test_ok():
+                   assert True
+        """)
+        snippets = parse_rst(rst, tmp_path)
+        assert len(snippets) == 1
+        assert PYTESTRUN_MARK in snippets[0].marks
+
+    def test_rst_no_pytestrun_mark_by_default(self, tmp_path):
+        """A plain RST code block does NOT carry the pytestrun mark."""
+        rst = textwrap.dedent("""\
+            .. code-block:: python
+               :name: test_plain_rst
+
+               x = 1
+        """)
+        snippets = parse_rst(rst, tmp_path)
+        assert PYTESTRUN_MARK not in snippets[0].marks
+
+
+# ============================================================================
+# Test run_pytest_style_code directly
+# ============================================================================
+class TestRunPytestStyleCode:
+    """Unit tests for run_pytest_style_code helper."""
+
+    def test_passing_code_does_not_raise(self, tmp_path):
+        """A block with a passing test must not raise."""
+        code = textwrap.dedent("""\
+            def test_simple():
+                assert 1 + 1 == 2
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_simple",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_failing_code_raises_assertion_error(self, tmp_path):
+        """A block with a failing test must raise AssertionError."""
+        code = textwrap.dedent("""\
+            def test_fail():
+                assert False, "intentional failure"
+        """)
+        with pytest.raises(AssertionError, match="test_fail"):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_fail",
+                path=str(tmp_path / "dummy.md"),
+            )
+
+    def test_error_message_contains_snippet_name(self, tmp_path):
+        """The AssertionError message should reference the snippet name."""
+        code = textwrap.dedent("""\
+            def test_broken():
+                raise ValueError("boom")
+        """)
+        with pytest.raises(AssertionError) as exc_info:
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_broken_snippet",
+                path=str(tmp_path / "dummy.md"),
+            )
+        assert "test_broken_snippet" in str(exc_info.value)
+
+    def test_class_based_tests_pass(self, tmp_path):
+        """A block containing a Test* class should execute correctly."""
+        code = textwrap.dedent("""\
+            class TestMath:
+                def test_addition(self):
+                    assert 2 + 2 == 4
+
+                def test_subtraction(self):
+                    assert 5 - 3 == 2
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_math_class",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_class_based_tests_fail(self, tmp_path):
+        """A block with a failing Test* class must raise AssertionError."""
+        code = textwrap.dedent("""\
+            class TestBroken:
+                def test_bad(self):
+                    assert 1 == 2
+        """)
+        with pytest.raises(AssertionError):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_broken_class",
+                path=str(tmp_path / "dummy.md"),
+            )
+
+    def test_class_with_fixture_passes(self, tmp_path):
+        """A block using a class-level fixture should pass."""
+        code = textwrap.dedent("""\
+            import pytest
+
+            class TestFixture:
+                @pytest.fixture
+                def greeting(self):
+                    return "hello"
+
+                def test_greeting(self, greeting):
+                    assert greeting == "hello"
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_class_fixture",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_parametrize_passes(self, tmp_path):
+        """A block using @pytest.mark.parametrize should pass."""
+        code = textwrap.dedent("""\
+            import pytest
+
+            @pytest.mark.parametrize("n,expected", [(1, 2), (2, 4), (3, 6)])
+            def test_double(n, expected):
+                assert n * 2 == expected
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_parametrize",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_parametrize_failure_raises(self, tmp_path):
+        """A parametrized block with a bad case must raise AssertionError."""
+        code = textwrap.dedent("""\
+            import pytest
+
+            @pytest.mark.parametrize("n,expected", [(1, 99)])
+            def test_wrong(n, expected):
+                assert n * 2 == expected
+        """)
+        with pytest.raises(AssertionError):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_bad_parametrize",
+                path=str(tmp_path / "dummy.md"),
+            )
+
+    def test_setup_teardown_runs(self, tmp_path):
+        """setup_method / teardown_method hooks should execute correctly."""
+        code = textwrap.dedent("""\
+            class TestSetup:
+                def setup_method(self):
+                    self.value = 42
+
+                def test_value(self):
+                    assert self.value == 42
+
+                def teardown_method(self):
+                    self.value = None
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_setup_teardown",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_nested_fixtures_pass(self, tmp_path):
+        """Nested fixture dependencies should be resolved correctly."""
+        code = textwrap.dedent("""\
+            import pytest
+
+            class TestNested:
+                @pytest.fixture
+                def base(self):
+                    return 10
+
+                @pytest.fixture
+                def derived(self, base):
+                    return base * 3
+
+                def test_derived(self, derived):
+                    assert derived == 30
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_nested_fixtures",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_multiple_test_functions_all_pass(self, tmp_path):
+        """Multiple top-level test functions in one block should all run."""
+        code = textwrap.dedent("""\
+            def test_one():
+                assert "a" == "a"
+
+            def test_two():
+                assert [1, 2, 3][0] == 1
+
+            def test_three():
+                assert {"k": "v"}["k"] == "v"
+        """)
+        run_pytest_style_code(
+            code=code,
+            snippet_name="test_multiple_fns",
+            path=str(tmp_path / "dummy.md"),
+        )
+
+    def test_multiple_test_functions_one_fails(self, tmp_path):
+        """If any test function fails, AssertionError must be raised."""
+        code = textwrap.dedent("""\
+            def test_good():
+                assert True
+
+            def test_bad():
+                assert False
+        """)
+        with pytest.raises(AssertionError):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_multi_one_fails",
+                path=str(tmp_path / "dummy.md"),
+            )
+
+    def test_empty_code_raises_no_tests_collected(self, tmp_path):
+        """Empty block (no test functions) should fail with non-zero exit."""
+        code = "# no tests here\nx = 1\n"
+        with pytest.raises(AssertionError):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_empty_block",
+                path=str(tmp_path / "dummy.md"),
+            )
+
+    def test_syntax_error_in_code_raises(self, tmp_path):
+        """A block with a syntax error should cause a non-zero pytest exit."""
+        code = "def broken(:\n    pass\n"
+        with pytest.raises(AssertionError):
+            run_pytest_style_code(
+                code=code,
+                snippet_name="test_syntax_err",
+                path=str(tmp_path / "dummy.md"),
+            )

{pytest_codeblock-0.5.4 → pytest_codeblock-0.5.6/src/pytest_codeblock.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-codeblock
-Version: 0.5.4
+Version: 0.5.6
 Summary: Pytest plugin to collect and test code blocks in reStructuredText and Markdown files.
 Author-email: Artur Barseghyan <artur.barseghyan@gmail.com>
 Maintainer-email: Artur Barseghyan <artur.barseghyan@gmail.com>
@@ -146,8 +146,8 @@ Prerequisites
 Documentation
 =============
 - Documentation is available on `Read the Docs`_.
-- For `reStructuredText`_, see a dedicated `reStructuredText docs`_.
-- For `Markdown`_, see a dedicated `Markdown docs`_.
+- For `reStructuredText`, see a dedicated `reStructuredText docs`_.
+- For `Markdown`, see a dedicated `Markdown docs`_.
 - Both `reStructuredText docs`_ and `Markdown docs`_ have extensive
   documentation on `pytest`_ markers and corresponding ``conftest.py`` hooks.
 - For guidelines on contributing check the `Contributor guidelines`_.

pytest_codeblock-0.5.4/src/pytest_codeblock/collector.py

@@ -1,52 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Optional
-
-__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
-__copyright__ = "2025-2026 Artur Barseghyan"
-__license__ = "MIT"
-__all__ = (
-    "CodeSnippet",
-    "group_snippets",
-)
-
-
-@dataclass
-class CodeSnippet:
-    """Data container for an extracted code snippet."""
-    code: str  # The code content
-    line: int  # Starting line number in the source
-    name: Optional[str] = None  # Identifier for grouping (None if anonymous)
-    marks: list[str] = field(default_factory=list)
-    # Collected pytest marks (e.g. ['django_db']), parsed from doc comments
-    fixtures: list[str] = field(default_factory=list)
-    # Collected pytest fixtures (e.g. ['tmp_path']), parsed from doc comments
-
-
-def group_snippets(snippets: list[CodeSnippet]) -> list[CodeSnippet]:
-    """
-    Merge snippets with the same name into one CodeSnippet,
-    concatenating their code and accumulating marks.
-    Unnamed snippets get unique auto-names.
-    """
-    combined: list[CodeSnippet] = []
-    seen: dict[str, CodeSnippet] = {}
-    anon_count = 0
-
-    for sn in snippets:
-        key = sn.name
-        if not key:
-            anon_count += 1
-            key = f"codeblock{anon_count}"
-
-        if key in seen:
-            seen_sn = seen[key]
-            seen_sn.code += "\n" + sn.code
-            seen_sn.marks.extend(sn.marks)
-            seen_sn.fixtures.extend(sn.fixtures)
-        else:
-            sn.marks = list(sn.marks)  # copy
-            sn.fixtures = list(sn.fixtures)  # copy
-            seen[key] = sn
-            combined.append(sn)
-
-    return combined