rfctr: Sections gets document_part

To access header and footer parts, Section will need the document part
and the source for that will be its Sections parent proxy. Add
document_part as construction parameter for Sections and modify tests to
suit.

Author: ondrej-111

docx/document.py

@@ -137,7 +137,7 @@ def save(self, path_or_stream):
     @property
     def sections(self):
         """|Sections| object providing access to each section in this document."""
-        return Sections(self._element)
+        return Sections(self._element, self._part)
 
     @property
     def settings(self):

docx/section.py

@@ -13,16 +13,15 @@ class Sections(Sequence):
     Supports ``len()``, iteration, and indexed access.
     """
 
-    def __init__(self, document_elm):
+    def __init__(self, document_elm, document_part):
         super(Sections, self).__init__()
         self._document_elm = document_elm
+        self._document_part = document_part
 
     def __getitem__(self, key):
         if isinstance(key, slice):
-            sectPr_lst = self._document_elm.sectPr_lst[key]
-            return [Section(sectPr) for sectPr in sectPr_lst]
-        sectPr = self._document_elm.sectPr_lst[key]
-        return Section(sectPr)
+            return [Section(sectPr) for sectPr in self._document_elm.sectPr_lst[key]]
+        return Section(self._document_elm.sectPr_lst[key])
 
     def __iter__(self):
         for sectPr in self._document_elm.sectPr_lst:
@@ -33,7 +32,10 @@ def __len__(self):
 
 
 class Section(object):
-    """Document section, providing access to section and page-setup settings."""
+    """Document section, providing access to section and page setup settings.
+
+    Also provides access to headers and footers.
+    """
 
     def __init__(self, sectPr):
         super(Section, self).__init__()

tests/test_document.py

@@ -21,9 +21,7 @@
 from docx.text.run import Run
 
 from .unitutil.cxml import element, xml
-from .unitutil.mock import (
-    class_mock, instance_mock, method_mock, property_mock
-)
+from .unitutil.mock import class_mock, instance_mock, method_mock, property_mock
 
 
 class DescribeDocument(object):
@@ -106,10 +104,14 @@ def it_provides_access_to_its_paragraphs(self, paragraphs_fixture):
         paragraphs = document.paragraphs
         assert paragraphs is paragraphs_
 
-    def it_provides_access_to_its_sections(self, sections_fixture):
-        document, Sections_, sections_ = sections_fixture
+    def it_provides_access_to_its_sections(self, document_part_, Sections_, sections_):
+        document_elm = element('w:document')
+        Sections_.return_value = sections_
+        document = Document(document_elm, document_part_)
+
         sections = document.sections
-        Sections_.assert_called_once_with(document._element)
+
+        Sections_.assert_called_once_with(document_elm, document_part_)
         assert sections is sections_
 
     def it_provides_access_to_its_settings(self, settings_fixture):
@@ -245,13 +247,6 @@ def save_fixture(self, document_part_):
         file_ = 'foobar.docx'
         return document, file_
 
-    @pytest.fixture
-    def sections_fixture(self, Sections_, sections_):
-        document_elm = element('w:document')
-        document = Document(document_elm, None)
-        Sections_.return_value = sections_
-        return document, Sections_, sections_
-
     @pytest.fixture
     def settings_fixture(self, document_part_, settings_):
         document = Document(None, document_part_)

tests/test_section.py

@@ -7,54 +7,74 @@
 import pytest
 
 from docx.enum.section import WD_ORIENT, WD_SECTION
+from docx.parts.document import DocumentPart
 from docx.section import Section, Sections
 from docx.shared import Inches
 
 from .unitutil.cxml import element, xml
+from .unitutil.mock import call, class_mock, instance_mock
 
 
 class DescribeSections(object):
 
-    def it_knows_how_many_sections_it_contains(self, len_fixture):
-        sections, expected_len = len_fixture
-        assert len(sections) == expected_len
+    def it_knows_how_many_sections_it_contains(self):
+        sections = Sections(
+            element("w:document/w:body/(w:p/w:pPr/w:sectPr, w:sectPr)"), None
+        )
+        assert len(sections) == 2
 
-    def it_can_iterate_over_its_Section_instances(self, iter_fixture):
-        sections, expected_count = iter_fixture
-        section_count = 0
-        for section in sections:
-            section_count += 1
-            assert isinstance(section, Section)
-        assert section_count == expected_count
+    def it_can_iterate_over_its_Section_instances(self, Section_, section_):
+        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)
 
-    def it_can_access_its_Section_instances_by_index(self, index_fixture):
-        sections, indicies = index_fixture
-        assert len(sections[0:2]) == 2
-        for index in indicies:
-            assert isinstance(sections[index], Section)
+        section_lst = [s for s in sections]
 
-    # fixtures -------------------------------------------------------
+        assert Section_.call_args_list == [call(sectPrs[0]), call(sectPrs[1])]
+        assert section_lst == [section_, section_]
 
-    @pytest.fixture
-    def index_fixture(self, document_elm):
-        sections = Sections(document_elm)
-        return sections, [0, 1]
+    def it_can_access_its_Section_instances_by_index(self, Section_, section_):
+        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)
 
-    @pytest.fixture
-    def iter_fixture(self, document_elm):
-        sections = Sections(document_elm)
-        return sections, 2
+        section_lst = [sections[idx] for idx in range(3)]
 
-    @pytest.fixture
-    def len_fixture(self, document_elm):
-        sections = Sections(document_elm)
-        return sections, 2
+        assert Section_.call_args_list == [
+            call(sectPrs[0]), call(sectPrs[1]), call(sectPrs[2])
+        ]
+        assert section_lst == [section_, section_, section_]
+
+    def it_can_access_its_Section_instances_by_slice(self, Section_, section_):
+        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)
+
+        section_lst = sections[1:9]
+
+        assert Section_.call_args_list == [call(sectPrs[1]), call(sectPrs[2])]
+        assert section_lst == [section_, section_]
 
     # fixture components ---------------------------------------------
 
     @pytest.fixture
-    def document_elm(self):
-        return element('w:document/w:body/(w:p/w:pPr/w:sectPr, w:sectPr)')
+    def document_part_(self, request):
+        return instance_mock(request, DocumentPart)
+
+    @pytest.fixture
+    def Section_(self, request):
+        return class_mock(request, "docx.section.Section")
+
+    @pytest.fixture
+    def section_(self, request):
+        return instance_mock(request, Section)
 
 
 class DescribeSection(object):