def it_raises_on_slide_id_not_found(self, slide_part_, related_part_):
prs_elm = element(
"p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id="
"b,id=257},p:sldId{r:id=c,id=258})")
related_part_.return_value = "not the slide you're looking for"
prs_part = PresentationPart(None, None, None, prs_elm)
with pytest.raises(ValueError):
prs_part.slide_id(slide_part_)
def it_provides_access_to_a_related_slide(self, request, slide_,
related_part_):
slide_part_ = instance_mock(request, SlidePart, slide=slide_)
related_part_.return_value = slide_part_
prs_part = PresentationPart(None, None, None, None)
slide = prs_part.related_slide("rId42")
related_part_.assert_called_once_with(prs_part, "rId42")
assert slide is slide_
def it_finds_a_slide_by_slide_id(self, is_present, slide_, slide_part_,
related_part_):
prs_elm = element(
"p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id="
"b,id=257},p:sldId{r:id=c,id=258})")
slide_id = 257 if is_present else 666
expected_value = slide_ if is_present else None
related_part_.return_value = slide_part_
slide_part_.slide = slide_
prs_part = PresentationPart(None, None, None, prs_elm)
slide = prs_part.get_slide(slide_id)
assert slide == expected_value
def it_finds_the_slide_id_of_a_slide_part(self, slide_part_,
related_part_):
prs_elm = element(
"p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id="
"b,id=257},p:sldId{r:id=c,id=258})")
related_part_.side_effect = iter((None, slide_part_, None))
prs_part = PresentationPart(None, None, None, prs_elm)
_slide_id = prs_part.slide_id(slide_part_)
assert related_part_.call_args_list == [
call(prs_part, "a"),
call(prs_part, "b"),
]
assert _slide_id == 257
def it_can_rename_related_slide_parts(self, request, related_part_):
rIds = tuple("rId%d" % n for n in range(5, 0, -1))
slide_parts = tuple(
instance_mock(request, SlidePart) for _ in range(5))
related_part_.side_effect = iter(slide_parts)
prs_part = PresentationPart(None, None, None, None)
prs_part.rename_slide_parts(rIds)
assert related_part_.call_args_list == [
call(prs_part, rId) for rId in rIds
]
assert [s.partname for s in slide_parts] == [
PackURI("/ppt/slides/slide%d.xml" % (i + 1))
for i in range(len(rIds))
]
def slide_id_raises_fixture(self, slide_part_, related_parts_prop_):
prs_elm = element(
"p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id="
"b,id=257},p:sldId{r:id=c,id=258})")
prs_part = PresentationPart(None, None, prs_elm)
related_parts_prop_.return_value = {"a": None, "b": None, "c": None}
return prs_part, slide_part_
def slide_width_get_fixture(self):
cx = 8765432
presentation_elm = (a_presentation().with_nsdecls().with_child(
a_sldSz().with_cx(cx))).element
prs_part = PresentationPart(None, None, presentation_elm, None)
slide_width = cx
return prs_part, slide_width
def add_slide_fixture(
self,
package_,
slide_layout_,
SlidePart_,
slide_part_,
slide_,
_next_slide_partname_prop_,
relate_to_,
):
prs_part = PresentationPart(None, None, None, package_)
partname = _next_slide_partname_prop_.return_value
rId_ = "rId42"
SlidePart_.new.return_value = slide_part_
relate_to_.return_value = rId_
slide_layout_part_ = slide_layout_.part
slide_part_.slide = slide_
return (
prs_part,
slide_layout_,
SlidePart_,
partname,
package_,
slide_layout_part_,
slide_part_,
rId_,
slide_,
)
def slide_id_raises_fixture(self, slide_part_, related_parts_prop_):
prs_elm = element(
'p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id='
'b,id=257},p:sldId{r:id=c,id=258})')
prs_part = PresentationPart(None, None, prs_elm)
related_parts_prop_.return_value = {'a': None, 'b': None, 'c': None}
return prs_part, slide_part_
def slide_height_get_fixture(self):
cy = 5432109
presentation_elm = (a_presentation().with_nsdecls().with_child(
a_sldSz().with_cy(cy))).element
prs_part = PresentationPart(None, None, presentation_elm, None)
slide_height = cy
return prs_part, slide_height
def it_provides_access_to_its_presentation(self, request):
prs_ = instance_mock(request, Presentation)
Presentation_ = class_mock(request,
"pptx.parts.presentation.Presentation",
return_value=prs_)
prs_elm = element("p:presentation")
prs_part = PresentationPart(None, None, None, prs_elm)
prs = prs_part.presentation
Presentation_.assert_called_once_with(prs_elm, prs_part)
assert prs is prs_
def nmp_add_fixture(
self,
package_,
NotesMasterPart_,
notes_master_part_,
part_related_by_,
relate_to_,
):
prs_part = PresentationPart(None, None, None, package_)
part_related_by_.side_effect = KeyError
NotesMasterPart_.create_default.return_value = notes_master_part_
return prs_part, NotesMasterPart_, package_, notes_master_part_
def it_provides_access_to_its_notes_master(self, request,
notes_master_part_):
notes_master_ = instance_mock(request, NotesMaster)
property_mock(
request,
PresentationPart,
"notes_master_part",
return_value=notes_master_part_,
)
notes_master_part_.notes_master = notes_master_
prs_part = PresentationPart(None, None, None, None)
assert prs_part.notes_master is notes_master_
def it_provides_access_to_an_existing_notes_master_part(
self, notes_master_part_, part_related_by_):
"""This is the first of a two-part test to cover the existing notes master case.
The notes master not-present case follows.
"""
prs_part = PresentationPart(None, None, None, None)
part_related_by_.return_value = notes_master_part_
notes_master_part = prs_part.notes_master_part
prs_part.part_related_by.assert_called_once_with(
prs_part, RT.NOTES_MASTER)
assert notes_master_part is notes_master_part_
def it_can_add_a_new_slide(self, request, package_, slide_part_, slide_,
relate_to_):
slide_layout_ = instance_mock(request, SlideLayout)
partname = PackURI("/ppt/slides/slide9.xml")
property_mock(request,
PresentationPart,
"_next_slide_partname",
return_value=partname)
SlidePart_ = class_mock(request, "pptx.parts.presentation.SlidePart")
SlidePart_.new.return_value = slide_part_
relate_to_.return_value = "rId42"
slide_layout_part_ = slide_layout_.part
slide_part_.slide = slide_
prs_part = PresentationPart(None, None, package_, None)
rId, slide = prs_part.add_slide(slide_layout_)
SlidePart_.new.assert_called_once_with(partname, package_,
slide_layout_part_)
prs_part.relate_to.assert_called_once_with(prs_part, slide_part_,
RT.SLIDE)
assert rId == "rId42"
assert slide is slide_
def rename_fixture(self, related_parts_prop_):
prs_part = PresentationPart(None, None, None)
rIds = ('rId1', 'rId2')
getitem_ = related_parts_prop_.return_value.__getitem__
calls = [call('rId1'), call('rId2')]
slide_parts = [
SlidePart(None, None, None),
SlidePart(None, None, None),
]
expected_names = [
PackURI('/ppt/slides/slide1.xml'),
PackURI('/ppt/slides/slide2.xml'),
]
getitem_.side_effect = slide_parts
return (prs_part, rIds, getitem_, calls, slide_parts, expected_names)
def get_slide_fixture(self, request, slide_, slide_part_,
related_parts_prop_):
is_present = request.param
prs_elm = element(
'p:presentation/p:sldIdLst/(p:sldId{r:id=a,id=256},p:sldId{r:id='
'b,id=257},p:sldId{r:id=c,id=258})')
prs_part = PresentationPart(None, None, prs_elm)
slide_id = 257 if is_present else 666
expected_value = slide_ if is_present else None
related_parts_prop_.return_value = {
'a': None,
'b': slide_part_,
'c': None
}
slide_part_.slide = slide_
return prs_part, slide_id, expected_value
def but_it_adds_a_notes_master_part_when_needed(self, request, package_,
notes_master_part_,
part_related_by_,
relate_to_):
"""This is the second of a two-part test to cover notes-master-not-present case.
The notes master present case is just above.
"""
NotesMasterPart_ = class_mock(
request, "pptx.parts.presentation.NotesMasterPart")
NotesMasterPart_.create_default.return_value = notes_master_part_
part_related_by_.side_effect = KeyError
prs_part = PresentationPart(None, None, package_, None)
notes_master_part = prs_part.notes_master_part
NotesMasterPart_.create_default.assert_called_once_with(package_)
relate_to_.assert_called_once_with(prs_part, notes_master_part_,
RT.NOTES_MASTER)
assert notes_master_part is notes_master_part_
def next_fixture(self):
prs_elm = element('p:presentation/p:sldIdLst/(p:sldId,p:sldId)')
prs_part = PresentationPart(None, None, prs_elm)
partname = PackURI('/ppt/slides/slide3.xml')
return prs_part, partname
def it_knows_the_next_slide_partname_to_help(self):
prs_elm = element("p:presentation/p:sldIdLst/(p:sldId,p:sldId)")
prs_part = PresentationPart(None, None, None, prs_elm)
assert prs_part._next_slide_partname == PackURI(
"/ppt/slides/slide3.xml")
def masters_fixture(self):
presentation_part = PresentationPart(None, None, None, None)
return presentation_part
def presentation_part(self, presentation_elm):
return PresentationPart(None, None, presentation_elm, None)
def prs(self, ct_presentation_):
partname = PackURI('/ppt/presentation.xml')
prs = PresentationPart(partname, None, ct_presentation_, None)
return prs
def it_provides_access_to_its_core_properties(self, request, package_):
core_properties_ = instance_mock(request, CorePropertiesPart)
package_.core_properties = core_properties_
prs_part = PresentationPart(None, None, package_, None)
assert prs_part.core_properties is core_properties_
def slide_fixture(self, slide_, related_parts_prop_):
prs_part = PresentationPart(None, None, None, None)
rId = 'rId42'
related_parts_ = related_parts_prop_.return_value
related_parts_.__getitem__.return_value.slide = slide_
return prs_part, rId, slide_
def save_fixture(self, package_):
prs_part = PresentationPart(None, None, None, package_)
file_ = 'foobar.docx'
return prs_part, file_, package_
def prs_fixture(self, Presentation_, prs_):
prs_elm = element('p:presentation')
prs_part = PresentationPart(None, None, prs_elm)
return prs_part, Presentation_, prs_elm, prs_
def it_can_save_the_package_to_a_file(self, package_):
PresentationPart(None, None, package_, None).save("prs.pptx")
package_.save.assert_called_once_with("prs.pptx")
def core_props_fixture(self, package_, core_properties_):
prs_part = PresentationPart(None, None, None, package_)
package_.core_properties = core_properties_
return prs_part, core_properties_
def nmp_get_fixture(self, notes_master_part_, part_related_by_):
prs_part = PresentationPart(None, None, None, None)
part_related_by_.return_value = notes_master_part_
return prs_part, notes_master_part_
