# encoding: utf-8
"""
Test suite for the docx.document module
"""
from __future__ import (
absolute_import, division, print_function, unicode_literals
)
import pytest
from docx.document import _Body, Document
from docx.enum.section import WD_SECTION
from docx.enum.text import WD_BREAK
from docx.opc.coreprops import CoreProperties
from docx.parts.document import DocumentPart
from docx.section import Section, Sections
from docx.shape import InlineShape, InlineShapes
from docx.shared import Length
from docx.styles.styles import Styles
from docx.table import Table
from docx.text.paragraph import Paragraph
from docx.text.run import Run
from .unitutil.cxml import element, xml
from .unitutil.mock import (
class_mock, instance_mock, method_mock, property_mock
)
class DescribeDocument(object):
def it_can_add_a_heading(self, add_heading_fixture):
document, text, level, style, paragraph_ = add_heading_fixture
paragraph = document.add_heading(text, level)
document.add_paragraph.assert_called_once_with(text, style)
assert paragraph is paragraph_
def it_raises_on_heading_level_out_of_range(self):
document = Document(None, None)
with pytest.raises(ValueError):
document.add_heading(level=-1)
with pytest.raises(ValueError):
document.add_heading(level=10)
def it_can_add_a_page_break(self, add_page_break_fixture):
document, paragraph_, run_ = add_page_break_fixture
paragraph = document.add_page_break()
document.add_paragraph.assert_called_once_with()
paragraph_.add_run.assert_called_once_with()
run_.add_break.assert_called_once_with(WD_BREAK.PAGE)
assert paragraph is paragraph_
def it_can_add_a_paragraph(self, add_paragraph_fixture):
document, text, style, paragraph_ = add_paragraph_fixture
paragraph = document.add_paragraph(text, style)
document._body.add_paragraph.assert_called_once_with(text, style)
assert paragraph is paragraph_
def it_can_add_a_picture(self, add_picture_fixture):
document, path, width, height, run_, picture_ = add_picture_fixture
picture = document.add_picture(path, width, height)
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:]
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)
assert section is section_
def it_can_add_a_table(self, add_table_fixture):
document, rows, cols, style, width, table_ = add_table_fixture
table = document.add_table(rows, cols, style)
document._body.add_table.assert_called_once_with(rows, cols, width)
assert table == table_
assert table.style == style
def it_can_save_the_document_to_a_file(self, save_fixture):
document, file_ = save_fixture
document.save(file_)
document._part.save.assert_called_once_with(file_)
def it_provides_access_to_its_core_properties(self, core_props_fixture):
document, core_properties_ = core_props_fixture
core_properties = document.core_properties
assert core_properties is core_properties_
def it_provides_access_to_its_inline_shapes(self, inline_shapes_fixture):
document, inline_shapes_ = inline_shapes_fixture
assert document.inline_shapes is inline_shapes_
def it_provides_access_to_its_paragraphs(self, paragraphs_fixture):
document, paragraphs_ = paragraphs_fixture
paragraphs = document.paragraphs
assert paragraphs is paragraphs_
def it_provides_access_to_its_sections(self, sections_fixture):
document, Sections_, sections_ = sections_fixture
sections = document.sections
Sections_.assert_called_once_with(document._element)
assert sections is sections_
def it_provides_access_to_its_styles(self, styles_fixture):
document, styles_ = styles_fixture
assert document.styles is styles_
def it_provides_access_to_its_tables(self, tables_fixture):
document, tables_ = tables_fixture
tables = document.tables
assert tables is tables_
def it_provides_access_to_the_document_part(self, part_fixture):
document, part_ = part_fixture
assert document.part is part_
def it_provides_access_to_the_document_body(self, body_fixture):
document, body_elm, _Body_, body_ = body_fixture
body = document._body
_Body_.assert_called_once_with(body_elm, document)
assert body is body_
def it_determines_block_width_to_help(self, block_width_fixture):
document, expected_value = block_width_fixture
width = document._block_width
assert isinstance(width, Length)
assert width == expected_value
# fixtures -------------------------------------------------------
@pytest.fixture(params=[
(0, 'Title'),
(1, 'Heading 1'),
(2, 'Heading 2'),
(9, 'Heading 9'),
])
def add_heading_fixture(self, request, add_paragraph_, paragraph_):
level, style = request.param
document = Document(None, None)
text = 'Spam vs. Bacon'
add_paragraph_.return_value = paragraph_
return document, text, level, style, paragraph_
@pytest.fixture
def add_page_break_fixture(self, add_paragraph_, paragraph_, run_):
document = Document(None, None)
add_paragraph_.return_value = paragraph_
paragraph_.add_run.return_value = run_
return document, paragraph_, run_
@pytest.fixture(params=[
('', None),
('', 'Heading 1'),
('foo\rbar', 'Body Text'),
])
def add_paragraph_fixture(self, request, body_prop_, paragraph_):
text, style = request.param
document = Document(None, None)
body_prop_.return_value.add_paragraph.return_value = paragraph_
return document, text, style, paragraph_
@pytest.fixture
def add_picture_fixture(self, request, add_paragraph_, run_, picture_):
document = Document(None, None)
path, width, height = 'foobar.png', 100, 200
add_paragraph_.return_value.add_run.return_value = run_
run_.add_picture.return_value = picture_
return document, path, width, height, run_, picture_
@pytest.fixture(params=[
('w:sectPr', WD_SECTION.EVEN_PAGE,
'w:sectPr/w:type{w:val=evenPage}'),
('w:sectPr/w:type{w:val=evenPage}', WD_SECTION.ODD_PAGE,
'w:sectPr/w:type{w:val=oddPage}'),
('w:sectPr/w:type{w:val=oddPage}', WD_SECTION.NEW_PAGE,
'w:sectPr'),
])
def add_section_fixture(self, request, Section_):
sentinel, start_type, new_sentinel = request.param
document_cxml = 'w:document/w:body/(w:p,%s)' % sentinel
document = Document(element(document_cxml), None)
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
@pytest.fixture
def add_table_fixture(self, _block_width_prop_, body_prop_, table_):
document = Document(None, None)
rows, cols, style = 4, 2, 'Light Shading Accent 1'
body_prop_.return_value.add_table.return_value = table_
_block_width_prop_.return_value = width = 42
return document, rows, cols, style, width, table_
@pytest.fixture
def block_width_fixture(self, sections_prop_, section_):
document = Document(None, None)
sections_prop_.return_value = [None, section_]
section_.page_width = 6000
section_.left_margin = 1500
section_.right_margin = 1000
expected_value = 3500
return document, expected_value
@pytest.fixture
def body_fixture(self, _Body_, body_):
document_elm = element('w:document/w:body')
body_elm = document_elm[0]
document = Document(document_elm, None)
return document, body_elm, _Body_, body_
@pytest.fixture
def core_props_fixture(self, document_part_, core_properties_):
document = Document(None, document_part_)
document_part_.core_properties = core_properties_
return document, core_properties_
@pytest.fixture
def inline_shapes_fixture(self, document_part_, inline_shapes_):
document = Document(None, document_part_)
document_part_.inline_shapes = inline_shapes_
return document, inline_shapes_
@pytest.fixture
def paragraphs_fixture(self, body_prop_, paragraphs_):
document = Document(None, None)
body_prop_.return_value.paragraphs = paragraphs_
return document, paragraphs_
@pytest.fixture
def part_fixture(self, document_part_):
document = Document(None, document_part_)
return document, document_part_
@pytest.fixture
def save_fixture(self, document_part_):
document = Document(None, 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 styles_fixture(self, document_part_, styles_):
document = Document(None, document_part_)
document_part_.styles = styles_
return document, styles_
@pytest.fixture
def tables_fixture(self, body_prop_, tables_):
document = Document(None, None)
body_prop_.return_value.tables = tables_
return document, tables_
# fixture components ---------------------------------------------
@pytest.fixture
def add_paragraph_(self, request):
return method_mock(request, Document, 'add_paragraph')
@pytest.fixture
def _Body_(self, request, body_):
return class_mock(request, 'docx.document._Body', return_value=body_)
@pytest.fixture
def body_(self, request):
return instance_mock(request, _Body)
@pytest.fixture
def _block_width_prop_(self, request):
return property_mock(request, Document, '_block_width')
@pytest.fixture
def body_prop_(self, request, body_):
return property_mock(request, Document, '_body', return_value=body_)
@pytest.fixture
def core_properties_(self, request):
return instance_mock(request, CoreProperties)
@pytest.fixture
def document_part_(self, request):
return instance_mock(request, DocumentPart)
@pytest.fixture
def inline_shapes_(self, request):
return instance_mock(request, InlineShapes)
@pytest.fixture
def paragraph_(self, request):
return instance_mock(request, Paragraph)
@pytest.fixture
def paragraphs_(self, request):
return instance_mock(request, list)
@pytest.fixture
def picture_(self, request):
return instance_mock(request, InlineShape)
@pytest.fixture
def run_(self, request):
return instance_mock(request, Run)
@pytest.fixture
def Section_(self, request):
return class_mock(request, 'docx.document.Section')
@pytest.fixture
def section_(self, request):
return instance_mock(request, Section)
@pytest.fixture
def Sections_(self, request):
return class_mock(request, 'docx.document.Sections')
@pytest.fixture
def sections_(self, request):
return instance_mock(request, Sections)
@pytest.fixture
def sections_prop_(self, request):
return property_mock(request, Document, 'sections')
@pytest.fixture
def styles_(self, request):
return instance_mock(request, Styles)
@pytest.fixture
def table_(self, request):
return instance_mock(request, Table, style='UNASSIGNED')
@pytest.fixture
def tables_(self, request):
return instance_mock(request, list)
class Describe_Body(object):
def it_can_clear_itself_of_all_content_it_holds(self, clear_fixture):
body, expected_xml = clear_fixture
_body = body.clear_content()
assert body._body.xml == expected_xml
assert _body is body
# fixtures -------------------------------------------------------
@pytest.fixture(params=[
('w:body', 'w:body'),
('w:body/w:p', 'w:body'),
('w:body/w:sectPr', 'w:body/w:sectPr'),
('w:body/(w:p, w:sectPr)', 'w:body/w:sectPr'),
])
def clear_fixture(self, request):
before_cxml, after_cxml = request.param
body = _Body(element(before_cxml), None)
expected_xml = xml(after_cxml)
return body, expected_xml