rfctr: Section gets document_part

* Modernize section unit test fixtures while in there.

Author: ondrej-111

docx/document.py

@@ -80,7 +80,7 @@ def add_section(self, start_type=WD_SECTION.NEW_PAGE):
         """
         new_sectPr = self._element.body.add_section_break()
         new_sectPr.start_type = start_type
-        return Section(new_sectPr)
+        return Section(new_sectPr, self._part)
 
     def add_table(self, rows, cols, style=None):
         """

docx/section.py

@@ -20,12 +20,15 @@ def __init__(self, document_elm, document_part):
 
     def __getitem__(self, key):
         if isinstance(key, slice):
-            return [Section(sectPr) for sectPr in self._document_elm.sectPr_lst[key]]
-        return Section(self._document_elm.sectPr_lst[key])
+            return [
+                Section(sectPr, self._document_part)
+                for sectPr in self._document_elm.sectPr_lst[key]
+            ]
+        return Section(self._document_elm.sectPr_lst[key], self._document_part)
 
     def __iter__(self):
         for sectPr in self._document_elm.sectPr_lst:
-            yield Section(sectPr)
+            yield Section(sectPr, self._document_part)
 
     def __len__(self):
         return len(self._document_elm.sectPr_lst)
@@ -37,9 +40,10 @@ class Section(object):
     Also provides access to headers and footers.
     """
 
-    def __init__(self, sectPr):
+    def __init__(self, sectPr, document_part):
         super(Section, self).__init__()
         self._sectPr = sectPr
+        self._document_part = document_part
 
     @property
     def bottom_margin(self):

tests/test_document.py

@@ -67,15 +67,18 @@ def it_can_add_a_picture(self, add_picture_fixture):
         run_.add_picture.assert_called_once_with(path, width, height)
         assert picture is picture_
 
-    def it_can_add_a_section(self, add_section_fixture):
-        document, start_type, Section_ = add_section_fixture[:3]
-        section_, expected_xml = add_section_fixture[3:]
+    def it_can_add_a_section(
+        self, add_section_fixture, Section_, section_, document_part_
+    ):
+        document_elm, start_type, expected_xml = add_section_fixture
+        Section_.return_value = section_
+        document = Document(document_elm, document_part_)
 
         section = document.add_section(start_type)
 
         assert document.element.xml == expected_xml
         sectPr = document.element.xpath('w:body/w:sectPr')[0]
-        Section_.assert_called_once_with(sectPr)
+        Section_.assert_called_once_with(sectPr, document_part_)
         assert section is section_
 
     def it_can_add_a_table(self, add_table_fixture):
@@ -182,16 +185,14 @@ def add_picture_fixture(self, request, add_paragraph_, run_, picture_):
         ('w:sectPr/w:type{w:val=oddPage}',  WD_SECTION.NEW_PAGE,
          'w:sectPr'),
     ])
-    def add_section_fixture(self, request, Section_):
+    def add_section_fixture(self, request):
         sentinel, start_type, new_sentinel = request.param
-        document_cxml = 'w:document/w:body/(w:p,%s)' % sentinel
-        document = Document(element(document_cxml), None)
+        document_elm = element('w:document/w:body/(w:p,%s)' % sentinel)
         expected_xml = xml(
             'w:document/w:body/(w:p,w:p/w:pPr/%s,%s)' %
             (sentinel, new_sentinel)
         )
-        section_ = Section_.return_value
-        return document, start_type, Section_, section_, expected_xml
+        return document_elm, start_type, expected_xml
 
     @pytest.fixture
     def add_table_fixture(self, _block_width_prop_, body_prop_, table_):

tests/test_section.py

@@ -23,43 +23,55 @@ def it_knows_how_many_sections_it_contains(self):
         )
         assert len(sections) == 2
 
-    def it_can_iterate_over_its_Section_instances(self, Section_, section_):
+    def it_can_iterate_over_its_Section_instances(
+        self, Section_, section_, document_part_
+    ):
         document_elm = element("w:document/w:body/(w:p/w:pPr/w:sectPr, w:sectPr)")
         sectPrs = document_elm.xpath("//w:sectPr")
         Section_.return_value = section_
-        sections = Sections(document_elm, None)
+        sections = Sections(document_elm, document_part_)
 
         section_lst = [s for s in sections]
 
-        assert Section_.call_args_list == [call(sectPrs[0]), call(sectPrs[1])]
+        assert Section_.call_args_list == [
+            call(sectPrs[0], document_part_), call(sectPrs[1], document_part_)
+        ]
         assert section_lst == [section_, section_]
 
-    def it_can_access_its_Section_instances_by_index(self, Section_, section_):
+    def it_can_access_its_Section_instances_by_index(
+        self, Section_, section_, document_part_
+    ):
         document_elm = element(
             "w:document/w:body/(w:p/w:pPr/w:sectPr,w:p/w:pPr/w:sectPr,w:sectPr)"
         )
         sectPrs = document_elm.xpath("//w:sectPr")
         Section_.return_value = section_
-        sections = Sections(document_elm, None)
+        sections = Sections(document_elm, document_part_)
 
         section_lst = [sections[idx] for idx in range(3)]
 
         assert Section_.call_args_list == [
-            call(sectPrs[0]), call(sectPrs[1]), call(sectPrs[2])
+            call(sectPrs[0], document_part_),
+            call(sectPrs[1], document_part_),
+            call(sectPrs[2], document_part_),
         ]
         assert section_lst == [section_, section_, section_]
 
-    def it_can_access_its_Section_instances_by_slice(self, Section_, section_):
+    def it_can_access_its_Section_instances_by_slice(
+        self, Section_, section_, document_part_
+    ):
         document_elm = element(
             "w:document/w:body/(w:p/w:pPr/w:sectPr,w:p/w:pPr/w:sectPr,w:sectPr)"
         )
         sectPrs = document_elm.xpath("//w:sectPr")
         Section_.return_value = section_
-        sections = Sections(document_elm, None)
+        sections = Sections(document_elm, document_part_)
 
         section_lst = sections[1:9]
 
-        assert Section_.call_args_list == [call(sectPrs[1]), call(sectPrs[2])]
+        assert Section_.call_args_list == [
+            call(sectPrs[1], document_part_), call(sectPrs[2], document_part_)
+        ]
         assert section_lst == [section_, section_]
 
     # fixture components ---------------------------------------------
@@ -80,51 +92,83 @@ def section_(self, request):
 class DescribeSection(object):
 
     def it_knows_its_start_type(self, start_type_get_fixture):
-        section, expected_start_type = start_type_get_fixture
-        assert section.start_type is expected_start_type
+        sectPr, expected_start_type = start_type_get_fixture
+        section = Section(sectPr, None)
+
+        start_type = section.start_type
+
+        assert start_type is expected_start_type
 
     def it_can_change_its_start_type(self, start_type_set_fixture):
-        section, new_start_type, expected_xml = start_type_set_fixture
+        sectPr, new_start_type, expected_xml = start_type_set_fixture
+        section = Section(sectPr, None)
+
         section.start_type = new_start_type
+
         assert section._sectPr.xml == expected_xml
 
     def it_knows_its_page_width(self, page_width_get_fixture):
-        section, expected_page_width = page_width_get_fixture
-        assert section.page_width == expected_page_width
+        sectPr, expected_page_width = page_width_get_fixture
+        section = Section(sectPr, None)
+
+        page_width = section.page_width
+
+        assert page_width == expected_page_width
 
     def it_can_change_its_page_width(self, page_width_set_fixture):
-        section, new_page_width, expected_xml = page_width_set_fixture
+        sectPr, new_page_width, expected_xml = page_width_set_fixture
+        section = Section(sectPr, None)
+
         section.page_width = new_page_width
+
         assert section._sectPr.xml == expected_xml
 
     def it_knows_its_page_height(self, page_height_get_fixture):
-        section, expected_page_height = page_height_get_fixture
-        assert section.page_height == expected_page_height
+        sectPr, expected_page_height = page_height_get_fixture
+        section = Section(sectPr, None)
+
+        page_height = section.page_height
+
+        assert page_height == expected_page_height
 
     def it_can_change_its_page_height(self, page_height_set_fixture):
-        section, new_page_height, expected_xml = page_height_set_fixture
+        sectPr, new_page_height, expected_xml = page_height_set_fixture
+        section = Section(sectPr, None)
+
         section.page_height = new_page_height
+
         assert section._sectPr.xml == expected_xml
 
     def it_knows_its_page_orientation(self, orientation_get_fixture):
-        section, expected_orientation = orientation_get_fixture
-        assert section.orientation is expected_orientation
+        sectPr, expected_orientation = orientation_get_fixture
+        section = Section(sectPr, None)
+
+        orientation = section.orientation
+
+        assert orientation is expected_orientation
 
     def it_can_change_its_orientation(self, orientation_set_fixture):
-        section, new_orientation, expected_xml = orientation_set_fixture
+        sectPr, new_orientation, expected_xml = orientation_set_fixture
+        section = Section(sectPr, None)
+
         section.orientation = new_orientation
+
         assert section._sectPr.xml == expected_xml
 
     def it_knows_its_page_margins(self, margins_get_fixture):
-        section, margin_prop_name, expected_value = margins_get_fixture
+        sectPr, margin_prop_name, expected_value = margins_get_fixture
+        section = Section(sectPr, None)
+
         value = getattr(section, margin_prop_name)
+
         assert value == expected_value
 
     def it_can_change_its_page_margins(self, margins_set_fixture):
-        section, margin_prop_name, new_value, expected_xml = (
-            margins_set_fixture
-        )
+        sectPr, margin_prop_name, new_value, expected_xml = margins_set_fixture
+        section = Section(sectPr, None)
+
         setattr(section, margin_prop_name, new_value)
+
         assert section._sectPr.xml == expected_xml
 
     # fixtures -------------------------------------------------------
@@ -142,8 +186,8 @@ def it_can_change_its_page_margins(self, margins_set_fixture):
     ])
     def margins_get_fixture(self, request):
         sectPr_cxml, margin_prop_name, expected_value = request.param
-        section = Section(element(sectPr_cxml))
-        return section, margin_prop_name, expected_value
+        sectPr = element(sectPr_cxml)
+        return sectPr, margin_prop_name, expected_value
 
     @pytest.fixture(params=[
         ('w:sectPr', 'left_margin',     Inches(1),
@@ -166,9 +210,9 @@ def margins_get_fixture(self, request):
     ])
     def margins_set_fixture(self, request):
         sectPr_cxml, property_name, new_value, expected_cxml = request.param
-        section = Section(element(sectPr_cxml))
+        sectPr = element(sectPr_cxml)
         expected_xml = xml(expected_cxml)
-        return section, property_name, new_value, expected_xml
+        return sectPr, property_name, new_value, expected_xml
 
     @pytest.fixture(params=[
         ('w:sectPr/w:pgSz{w:orient=landscape}', WD_ORIENT.LANDSCAPE),
@@ -178,8 +222,8 @@ def margins_set_fixture(self, request):
     ])
     def orientation_get_fixture(self, request):
         sectPr_cxml, expected_orientation = request.param
-        section = Section(element(sectPr_cxml))
-        return section, expected_orientation
+        sectPr = element(sectPr_cxml)
+        return sectPr, expected_orientation
 
     @pytest.fixture(params=[
         (WD_ORIENT.LANDSCAPE, 'w:sectPr/w:pgSz{w:orient=landscape}'),
@@ -188,9 +232,9 @@ def orientation_get_fixture(self, request):
     ])
     def orientation_set_fixture(self, request):
         new_orientation, expected_cxml = request.param
-        section = Section(element('w:sectPr'))
+        sectPr = element('w:sectPr')
         expected_xml = xml(expected_cxml)
-        return section, new_orientation, expected_xml
+        return sectPr, new_orientation, expected_xml
 
     @pytest.fixture(params=[
         ('w:sectPr/w:pgSz{w:h=2880}', Inches(2)),
@@ -199,18 +243,18 @@ def orientation_set_fixture(self, request):
     ])
     def page_height_get_fixture(self, request):
         sectPr_cxml, expected_page_height = request.param
-        section = Section(element(sectPr_cxml))
-        return section, expected_page_height
+        sectPr = element(sectPr_cxml)
+        return sectPr, expected_page_height
 
     @pytest.fixture(params=[
         (None,      'w:sectPr/w:pgSz'),
         (Inches(2), 'w:sectPr/w:pgSz{w:h=2880}'),
     ])
     def page_height_set_fixture(self, request):
         new_page_height, expected_cxml = request.param
-        section = Section(element('w:sectPr'))
+        sectPr = element('w:sectPr')
         expected_xml = xml(expected_cxml)
-        return section, new_page_height, expected_xml
+        return sectPr, new_page_height, expected_xml
 
     @pytest.fixture(params=[
         ('w:sectPr/w:pgSz{w:w=1440}', Inches(1)),
@@ -219,18 +263,18 @@ def page_height_set_fixture(self, request):
     ])
     def page_width_get_fixture(self, request):
         sectPr_cxml, expected_page_width = request.param
-        section = Section(element(sectPr_cxml))
-        return section, expected_page_width
+        sectPr = element(sectPr_cxml)
+        return sectPr, expected_page_width
 
     @pytest.fixture(params=[
         (None,      'w:sectPr/w:pgSz'),
         (Inches(4), 'w:sectPr/w:pgSz{w:w=5760}'),
     ])
     def page_width_set_fixture(self, request):
         new_page_width, expected_cxml = request.param
-        section = Section(element('w:sectPr'))
+        sectPr = element('w:sectPr')
         expected_xml = xml(expected_cxml)
-        return section, new_page_width, expected_xml
+        return sectPr, new_page_width, expected_xml
 
     @pytest.fixture(params=[
         ('w:sectPr',                          WD_SECTION.NEW_PAGE),
@@ -243,8 +287,8 @@ def page_width_set_fixture(self, request):
     ])
     def start_type_get_fixture(self, request):
         sectPr_cxml, expected_start_type = request.param
-        section = Section(element(sectPr_cxml))
-        return section, expected_start_type
+        sectPr = element(sectPr_cxml)
+        return sectPr, expected_start_type
 
     @pytest.fixture(params=[
         ('w:sectPr/w:type{w:val=oddPage}',    WD_SECTION.EVEN_PAGE,
@@ -262,6 +306,6 @@ def start_type_get_fixture(self, request):
     ])
     def start_type_set_fixture(self, request):
         initial_cxml, new_start_type, expected_cxml = request.param
-        section = Section(element(initial_cxml))
+        sectPr = element(initial_cxml)
         expected_xml = xml(expected_cxml)
-        return section, new_start_type, expected_xml
+        return sectPr, new_start_type, expected_xml