python-docx/tests/test_blkcntnr.py at develop · python-openxml/python-docx · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
# pyright: reportPrivateUsage=false

"""Test suite for the docx.blkcntnr (block item container) module."""

from __future__ import annotations

from typing import cast

import pytest

import docx
from docx.blkcntnr import BlockItemContainer
from docx.document import Document
from docx.oxml.document import CT_Body
from docx.shared import Inches
from docx.table import Table
from docx.text.paragraph import Paragraph

from .unitutil.cxml import element, xml
from .unitutil.file import snippet_seq, test_file
from .unitutil.mock import FixtureRequest, Mock, call, instance_mock, method_mock


class DescribeBlockItemContainer:
    """Unit-test suite for `docx.blkcntnr.BlockItemContainer`."""

    @pytest.mark.parametrize(
        ("text", "style"), [("", None), ("Foo", None), ("", "Bar"), ("Foo", "Bar")]
    )
    def it_can_add_a_paragraph(
        self,
        text: str,
        style: str | None,
        blkcntnr: BlockItemContainer,
        _add_paragraph_: Mock,
        paragraph_: Mock,
    ):
        paragraph_.style = None
        _add_paragraph_.return_value = paragraph_

        paragraph = blkcntnr.add_paragraph(text, style)

        _add_paragraph_.assert_called_once_with(blkcntnr)
        assert paragraph_.add_run.call_args_list == ([call(text)] if text else [])
        assert paragraph.style == style
        assert paragraph is paragraph_

    def it_can_add_a_table(self, blkcntnr: BlockItemContainer):
        rows, cols, width = 2, 2, Inches(2)

        table = blkcntnr.add_table(rows, cols, width)

        assert isinstance(table, Table)
        assert table._element.xml == snippet_seq("new-tbl")[0]
        assert table._parent is blkcntnr

    def it_can_iterate_its_inner_content(self):
        document = docx.Document(test_file("blk-inner-content.docx"))

        inner_content = document.iter_inner_content()

        para = next(inner_content)
        assert isinstance(para, Paragraph)
        assert para.text == "P1"
        # --
        t = next(inner_content)
        assert isinstance(t, Table)
        assert t.rows[0].cells[0].text == "T2"
        # --
        para = next(inner_content)
        assert isinstance(para, Paragraph)
        assert para.text == "P3"
        # --
        with pytest.raises(StopIteration):
            next(inner_content)

    @pytest.mark.parametrize(
        ("blkcntnr_cxml", "expected_count"),
        [
            ("w:body", 0),
            ("w:body/w:p", 1),
            ("w:body/(w:p,w:p)", 2),
            ("w:body/(w:p,w:tbl)", 1),
            ("w:body/(w:p,w:tbl,w:p)", 2),
        ],
    )
    def it_provides_access_to_the_paragraphs_it_contains(
        self, blkcntnr_cxml: str, expected_count: int, document_: Mock
    ):
        blkcntnr = BlockItemContainer(cast(CT_Body, element(blkcntnr_cxml)), document_)

        paragraphs = blkcntnr.paragraphs

        # -- supports len() --
        assert len(paragraphs) == expected_count
        # -- is iterable --
        assert all(isinstance(p, Paragraph) for p in paragraphs)
        # -- is indexable --
        assert all(p is paragraphs[idx] for idx, p in enumerate(paragraphs))

    @pytest.mark.parametrize(
        ("blkcntnr_cxml", "expected_count"),
        [
            ("w:body", 0),
            ("w:body/w:tbl", 1),
            ("w:body/(w:tbl,w:tbl)", 2),
            ("w:body/(w:p,w:tbl)", 1),
            ("w:body/(w:tbl,w:tbl,w:p)", 2),
        ],
    )
    def it_provides_access_to_the_tables_it_contains(
        self, blkcntnr_cxml: str, expected_count: int, document_: Mock
    ):
        blkcntnr = BlockItemContainer(cast(CT_Body, element(blkcntnr_cxml)), document_)

        tables = blkcntnr.tables

        # -- supports len() --
        assert len(tables) == expected_count
        # -- is iterable --
        assert all(isinstance(t, Table) for t in tables)
        # -- is indexable --
        assert all(t is tables[idx] for idx, t in enumerate(tables))

    def it_adds_a_paragraph_to_help(self, document_: Mock):
        blkcntnr = BlockItemContainer(cast(CT_Body, element("w:body")), document_)

        new_paragraph = blkcntnr._add_paragraph()

        assert isinstance(new_paragraph, Paragraph)
        assert new_paragraph._parent == blkcntnr
        assert blkcntnr._element.xml == xml("w:body/w:p")

    # -- fixtures --------------------------------------------------------------------------------

    @pytest.fixture
    def _add_paragraph_(self, request: FixtureRequest):
        return method_mock(request, BlockItemContainer, "_add_paragraph")

    @pytest.fixture
    def blkcntnr(self, document_: Mock):
        blkcntnr_elm = cast(CT_Body, element("w:body"))
        return BlockItemContainer(blkcntnr_elm, document_)

    @pytest.fixture
    def document_(self, request: FixtureRequest):
        return instance_mock(request, Document)

    @pytest.fixture
    def paragraph_(self, request: FixtureRequest):
        return instance_mock(request, Paragraph)