Enterprise agent platform for building, deploying, and operating AI teammates.
import io
import json
import zipfile
from unittest.mock import MagicMock, Mock
import pytest
import requests
from lxml import etree
from pptx import Presentation
from pptx.enum.text import PP_ALIGN
from pptx.opc.constants import RELATIONSHIP_TYPE as RT
from pptx.oxml.ns import qn
from pptx.util import Inches, Pt
from xagent.core.tools.adapters.vibe.output_filter import OutputValueFilter
from xagent.web.tools.mcp import powerpoint
def _pptx_bytes(build_fn=None) -> bytes:
presentation = Presentation()
if build_fn:
build_fn(presentation)
buffer = io.BytesIO()
presentation.save(buffer)
return buffer.getvalue()
class MockResponse:
def __init__(self, json_data=None, status_code=200, content=None, url=None):
self._json_data = json_data if json_data is not None else {}
self.status_code = status_code
self.content = (
json.dumps(self._json_data).encode("utf-8") if content is None else content
)
self.text = self.content.decode("utf-8", errors="replace")
self.url = url or "https://graph.microsoft.com/v1.0/example"
def json(self):
return self._json_data
def raise_for_status(self):
if self.status_code >= 400:
raise requests.HTTPError(
f"{self.status_code} Client Error: Error for url: {self.url}",
response=self,
)
def iter_content(self, chunk_size=1):
for start in range(0, len(self.content), chunk_size):
yield self.content[start : start + chunk_size]
def close(self):
return None
def _metadata_response(content: bytes, etag: str = '"etag-1"') -> MockResponse:
return MockResponse(
{
"id": "item-1",
"size": len(content),
"eTag": etag,
"parentReference": {"driveId": "drive-1"},
"@microsoft.graph.downloadUrl": "https://download.example/deck.pptx",
}
)
def _mock_download(monkeypatch, content: bytes, etag: str = '"etag-1"'):
mock_request = Mock(return_value=_metadata_response(content, etag))
mock_get = Mock(return_value=MockResponse(content=content))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
return mock_request, mock_get
def _mock_versioned_write(monkeypatch, content: bytes, etag: str = '"etag-1"'):
responses = iter(
[
_metadata_response(content, etag),
MockResponse({"uploadUrl": "https://upload.example/session"}),
]
)
mock_request = Mock(side_effect=lambda *a, **k: next(responses))
mock_get = Mock(return_value=MockResponse(content=content))
mock_put = Mock(return_value=MockResponse({"id": "item-1"}, status_code=200))
mock_session_cls = MagicMock()
mock_session_cls.return_value.__enter__.return_value.put = mock_put
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
return mock_request, mock_get, mock_put
@pytest.fixture(autouse=True)
def _credentials(monkeypatch):
monkeypatch.setenv("AUTH_TOKEN", "test-graph-token")
@pytest.mark.parametrize(
("response_factory", "expected_status"),
[
(
lambda: powerpoint._success(
item={"id": "x" * 500, "name": "y" * 500},
slide_index=3,
),
"success",
),
(lambda: powerpoint._error("x" * 500, details={"raw": "y" * 500}), "error"),
(lambda: powerpoint._conflict("x" * 500), "conflict"),
(lambda: powerpoint._indeterminate("x" * 500), "indeterminate"),
],
)
def test_outcome_envelopes_survive_platform_string_filter(
monkeypatch, response_factory, expected_status
):
"""Mutation outcomes must be valid JSON after the generic output filter.
That filter truncates strings without understanding JSON, so PowerPoint
must make each envelope fit before returning it.
"""
max_chars = 80
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: max_chars)
raw = response_factory()
filtered = OutputValueFilter(
max_chars=max_chars, max_fields=100, max_recursion=10
).filter(raw, "powerpoint_mutation")
assert filtered == raw
assert len(raw) <= max_chars
result = json.loads(filtered)
assert result["status"] == expected_status
if expected_status == "indeterminate":
assert result["safe_to_retry"] is False
# OneDrive Personal serves the final upload-session response from its own
# _api/v2.0 endpoint, which names the signed download link
# "@content.downloadUrl" rather than Graph's "@microsoft.graph.downloadUrl".
_SIGNED_DOWNLOAD_URL = (
"https://my.microsoftpersonalcontent.com/personal/abc/_layouts/15/download.aspx"
"?UniqueId=item-1&tempauth=v1e.signed-bearer-secret&ApiVersion=2.0"
)
_ALLOWLISTED_ITEM = {
"id": "item-1",
"name": "Deck.pptx",
"eTag": '"{ITEM-1},2"',
"cTag": '"c:{ITEM-1},2"',
"size": 29221,
"webUrl": "https://onedrive.live.com/personal/abc/_layouts/15/doc.aspx?resid=item-1",
}
def _personal_onedrive_upload_item() -> dict:
return {
"@odata.context": (
"https://my.microsoftpersonalcontent.com/personal/abc/_api/v2.0/"
"$metadata#items/$entity"
),
"@content.downloadUrl": _SIGNED_DOWNLOAD_URL,
"@content.downloadUrlNoAuth": (
"https://my.microsoftpersonalcontent.com/personal/abc/_layouts/15/"
"download.aspx?UniqueId=item-1&ApiVersion=2.0"
),
"@microsoft.graph.downloadUrl": _SIGNED_DOWNLOAD_URL,
"parentReference": {"driveId": "drive-1", "path": "/drive/root:"},
"customFacet": {"value": "dropped"},
**_ALLOWLISTED_ITEM,
}
def _assert_caller_safe_success(raw: str) -> None:
assert "tempauth" not in raw
assert "downloadUrl" not in raw
result = json.loads(raw)
assert result["status"] == "success"
assert result["item"] == _ALLOWLISTED_ITEM
def test_success_envelope_emits_only_allowlisted_item_fields(monkeypatch):
"""A raw driveItem can carry provider-signed download links under field
names this module does not know about, so the success envelope must
project the item instead of passing it through."""
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: 5000)
_assert_caller_safe_success(
powerpoint._success(item=_personal_onedrive_upload_item())
)
def test_create_presentation_omits_personal_onedrive_signed_url(monkeypatch):
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
),
)
monkeypatch.setattr(
powerpoint.requests,
"put",
Mock(
return_value=MockResponse(_personal_onedrive_upload_item(), status_code=201)
),
)
_assert_caller_safe_success(powerpoint.powerpoint_create_presentation("Deck.pptx"))
def _build_two_titled_slides(prs):
for title in ("A", "B"):
prs.slides.add_slide(prs.slide_layouts[1]).shapes.title.text = title
@pytest.mark.parametrize(
("build", "call"),
[
(
None,
lambda: powerpoint.powerpoint_add_slide(
"Deck.pptx", '"etag-1"', title="New Title"
),
),
(
_build_two_titled_slides,
lambda: powerpoint.powerpoint_set_shape_text(
"Deck.pptx", 0, 0, "New Title", '"etag-1"'
),
),
(
_build_two_titled_slides,
lambda: powerpoint.powerpoint_delete_slide("Deck.pptx", 0, '"etag-1"'),
),
],
ids=["add_slide", "set_shape_text", "delete_slide"],
)
def test_replace_tools_omit_personal_onedrive_signed_url(monkeypatch, build, call):
_, _, mock_put = _mock_versioned_write(monkeypatch, _pptx_bytes(build))
mock_put.return_value = MockResponse(
_personal_onedrive_upload_item(), status_code=200
)
_assert_caller_safe_success(call())
def test_upload_helpers_return_only_the_caller_safe_projection(monkeypatch):
"""Pinned separately from _success so a caller that bypasses the
envelope still never receives the raw provider item."""
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
),
)
monkeypatch.setattr(
powerpoint.requests,
"put",
Mock(
return_value=MockResponse(_personal_onedrive_upload_item(), status_code=201)
),
)
mock_session_cls = MagicMock()
mock_session_cls.return_value.__enter__.return_value.put = Mock(
return_value=MockResponse(_personal_onedrive_upload_item(), status_code=200)
)
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
created = powerpoint._create_only_upload(b"pptx", "Deck.pptx", None, None)
replaced = powerpoint._upload_presentation_session(
b"pptx", "Deck.pptx", None, None, '"etag-1"'
)
assert created == _ALLOWLISTED_ITEM
assert replaced == _ALLOWLISTED_ITEM
# ---------------------------------------------------------------------------
# path helpers
# ---------------------------------------------------------------------------
def test_item_path_defaults_to_own_onedrive():
assert (
powerpoint._item_path("Deck.pptx", None, None) == "/me/drive/root:/Deck.pptx:"
)
def test_item_path_sharepoint_path_form_site_id_closes_colon_before_drive():
"""A "hostname:/server-relative-path" site_id must get a second,
closing colon before /drive -- Graph's documented example is
".../sites/contoso.sharepoint.com:/teams/hr:/drive"; without it Graph
parses "/drive" as part of the site-relative path instead."""
assert (
powerpoint._item_path("Deck.pptx", "contoso.sharepoint.com:/teams/hr", None)
== "/sites/contoso.sharepoint.com:/teams/hr:/drive/root:/Deck.pptx:"
)
def test_item_path_sharepoint_path_form_site_id_with_drive_id():
assert (
powerpoint._item_path(
"Deck.pptx", "contoso.sharepoint.com:/teams/hr", "drive-1"
)
== "/sites/contoso.sharepoint.com:/teams/hr:/drives/drive-1/root:/Deck.pptx:"
)
def test_item_path_sharepoint_composite_site_id_unaffected():
"""The composite "hostname,spSiteId,spWebId" form has no ':' and must
not get an extra colon inserted."""
assert (
powerpoint._item_path("Deck.pptx", "contoso.sharepoint.com,site,web", None)
== "/sites/contoso.sharepoint.com,site,web/drive/root:/Deck.pptx:"
)
def test_content_path_appends_content():
assert (
powerpoint._content_path("Deck.pptx", None, None)
== "/me/drive/root:/Deck.pptx:/content"
)
def test_normalize_relative_path_rejects_trailing_period():
with pytest.raises(ValueError, match="must not end with a period"):
powerpoint._normalize_relative_path("Deck.pptx.")
@pytest.mark.parametrize("path", ["Deck.pptm", "Deck.ppt", "Deck", "Deck.ppsx"])
def test_normalize_relative_path_rejects_unsupported_powerpoint_package(path):
with pytest.raises(ValueError, match=r"must name a \.pptx"):
powerpoint._normalize_relative_path(path)
def test_normalize_relative_path_allows_case_insensitive_pptx_extension():
assert powerpoint._normalize_relative_path("Deck.PPTX") == "Deck.PPTX"
def test_normalize_relative_path_rejects_dot_segments():
with pytest.raises(ValueError, match="must not contain"):
powerpoint._normalize_relative_path("../secret.pptx")
def test_normalize_relative_path_rejects_doubled_slash():
"""An empty segment (from a doubled '/') isn't '.' or '..' but would
still build a malformed root:/{path}: Graph URL if let through."""
with pytest.raises(ValueError, match="empty"):
powerpoint._normalize_relative_path("reports//Q1.pptx")
def test_site_segment_rejects_doubled_slash():
with pytest.raises(ValueError, match="empty"):
powerpoint._site_segment("contoso.sharepoint.com:/teams//hr")
def test_item_path_rejects_empty_site_id():
"""An empty string is a caller mistake (e.g. an upstream field
defaulting unset to "" instead of None), not "not provided" -- it must
not be silently treated the same as site_id=None and routed to
/me/drive instead."""
with pytest.raises(ValueError, match="site_id is required"):
powerpoint._item_path("Deck.pptx", "", None)
def test_item_path_rejects_empty_drive_id():
with pytest.raises(ValueError, match="drive_id"):
powerpoint._item_path("Deck.pptx", None, "")
# ---------------------------------------------------------------------------
# slide helpers
# ---------------------------------------------------------------------------
def test_shape_text_returns_none_for_non_text_shape():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
picture_placeholder_shapes = list(slide.shapes)
# A blank layout has no shapes at all; simulate a shape without a text
# frame via a connector, the simplest shape type with has_text_frame=False.
from pptx.enum.shapes import MSO_CONNECTOR
connector = slide.shapes.add_connector(
MSO_CONNECTOR.STRAIGHT, Inches(0), Inches(0), Inches(1), Inches(1)
)
assert not connector.has_text_frame
assert powerpoint._shape_text(connector) is None
assert picture_placeholder_shapes == []
def test_require_slide_out_of_range():
presentation = Presentation()
with pytest.raises(ValueError, match="out of range"):
powerpoint._require_slide(presentation, 0)
def test_require_int_accepts_int():
assert powerpoint._require_int(3, "slide_index") == 3
def test_require_int_rejects_non_int():
with pytest.raises(TypeError, match="slide_index must be an integer"):
powerpoint._require_int("0", "slide_index")
def test_require_int_rejects_bool():
"""bool is a subclass of int in Python -- isinstance(True, int) is True
-- so this must be checked explicitly rather than relying on isinstance
alone, since True/False are never valid slide/shape/layout indices."""
with pytest.raises(TypeError, match="slide_index must be an integer"):
powerpoint._require_int(True, "slide_index")
def _make_placeholder(idx: int, has_text_frame: bool) -> Mock:
placeholder = Mock()
placeholder.placeholder_format.idx = idx
placeholder.has_text_frame = has_text_frame
return placeholder
def test_select_body_placeholder_skips_title():
title = _make_placeholder(0, has_text_frame=True)
body = _make_placeholder(1, has_text_frame=True)
slide = Mock()
slide.placeholders = [title, body]
assert powerpoint._select_body_placeholder(slide) is body
def test_select_body_placeholder_skips_non_text_placeholder():
"""A picture/chart placeholder can sit at a lower idx than the real
text placeholder -- this must not stop at it and give up."""
title = _make_placeholder(0, has_text_frame=True)
picture = _make_placeholder(1, has_text_frame=False)
body = _make_placeholder(2, has_text_frame=True)
slide = Mock()
slide.placeholders = [title, picture, body]
assert powerpoint._select_body_placeholder(slide) is body
def test_select_body_placeholder_returns_none_when_no_match():
title = _make_placeholder(0, has_text_frame=True)
picture = _make_placeholder(1, has_text_frame=False)
slide = Mock()
slide.placeholders = [title, picture]
assert powerpoint._select_body_placeholder(slide) is None
def test_delete_slide_removes_correct_slide():
presentation = Presentation()
for title in ("A", "B", "C"):
slide = presentation.slides.add_slide(presentation.slide_layouts[1])
slide.shapes.title.text = title
powerpoint._delete_slide(presentation, 1)
assert [s.shapes.title.text for s in presentation.slides] == ["A", "C"]
def test_delete_slide_out_of_range():
presentation = Presentation()
with pytest.raises(ValueError, match="out of range"):
powerpoint._delete_slide(presentation, 0)
def test_delete_slide_prunes_relationship_and_part():
"""Removing only the <p:sldId> entry leaves the slide's own part and its
relationship in the saved package; _delete_slide must also drop the
relationship so the "deleted" slide's content doesn't survive a
save/reload round trip at all."""
presentation = Presentation()
for title in ("A", "B"):
slide = presentation.slides.add_slide(presentation.slide_layouts[1])
slide.shapes.title.text = title
rels_before = set(presentation.part.rels)
powerpoint._delete_slide(presentation, 0)
rels_after = set(presentation.part.rels)
assert rels_after < rels_before
assert len(rels_before) - len(rels_after) == 1
buffer = io.BytesIO()
presentation.save(buffer)
reloaded = Presentation(io.BytesIO(buffer.getvalue()))
assert [s.shapes.title.text for s in reloaded.slides] == ["B"]
def test_delete_slide_rejects_custom_show_reference_without_mutating():
presentation = Presentation()
target_slide = presentation.slides.add_slide(presentation.slide_layouts[6])
target = list(presentation.slides._sldIdLst)[0]
relationship_id = target.get(qn("r:id"))
custom_show_list = etree.SubElement(presentation._element, qn("p:custShowLst"))
custom_show = etree.SubElement(custom_show_list, qn("p:custShow"))
custom_show.set("name", "Referenced slide")
custom_show.set("id", "1")
custom_slide_list = etree.SubElement(custom_show, qn("p:sldLst"))
custom_slide = etree.SubElement(custom_slide_list, qn("p:sld"))
custom_slide.set(qn("r:id"), relationship_id)
with pytest.raises(ValueError, match="custom slide show"):
powerpoint._delete_slide(presentation, 0)
assert list(presentation.slides) == [target_slide]
assert relationship_id in presentation.part.rels
def test_delete_slide_rejects_link_from_another_slide_without_mutating():
presentation = Presentation()
source = presentation.slides.add_slide(presentation.slide_layouts[6])
target = presentation.slides.add_slide(presentation.slide_layouts[6])
source.part.relate_to(target.part, RT.SLIDE)
with pytest.raises(ValueError, match="linked from another slide"):
powerpoint._delete_slide(presentation, 1)
assert list(presentation.slides) == [source, target]
def test_delete_slide_rejects_section_reference_without_mutating():
presentation = Presentation()
target_slide = presentation.slides.add_slide(presentation.slide_layouts[6])
target = list(presentation.slides._sldIdLst)[0]
powerpoint_2010 = "http://schemas.microsoft.com/office/powerpoint/2010/main"
extension_list = etree.SubElement(presentation._element, qn("p:extLst"))
extension = etree.SubElement(extension_list, qn("p:ext"))
extension.set("uri", "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}")
section_list = etree.SubElement(extension, f"{{{powerpoint_2010}}}sectionLst")
section = etree.SubElement(section_list, f"{{{powerpoint_2010}}}section")
section.set("name", "Section 1")
section.set("id", "{00000000-0000-0000-0000-000000000001}")
section_slide_list = etree.SubElement(section, f"{{{powerpoint_2010}}}sldIdLst")
section_slide_id = etree.SubElement(
section_slide_list, f"{{{powerpoint_2010}}}sldId"
)
section_slide_id.set("id", target.get("id"))
with pytest.raises(ValueError, match="presentation section"):
powerpoint._delete_slide(presentation, 0)
assert list(presentation.slides) == [target_slide]
def test_delete_slide_with_notes_remains_supported():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
slide.notes_slide.notes_text_frame.text = "Speaker notes"
powerpoint._delete_slide(presentation, 0)
assert len(presentation.slides) == 0
buffer = io.BytesIO()
presentation.save(buffer)
assert len(Presentation(io.BytesIO(buffer.getvalue())).slides) == 0
# ---------------------------------------------------------------------------
# create
# ---------------------------------------------------------------------------
def test_create_presentation_rejects_unsupported_extension_before_graph(monkeypatch):
mock_request = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptm"))
assert result["status"] == "error"
assert ".pptx" in result["message"]
mock_request.assert_not_called()
def test_create_presentation_rejects_when_session_creation_conflicts(monkeypatch):
mock_request = Mock(
return_value=MockResponse(
{"error": {"code": "nameAlreadyExists"}}, status_code=409
)
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "error"
assert "already exists" in result["message"]
assert mock_request.call_args.kwargs["url"].endswith("createUploadSession")
def test_create_presentation_keeps_final_upload_conflict_definite(monkeypatch):
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(
powerpoint.requests,
"put",
Mock(return_value=MockResponse({}, status_code=409)),
)
# Cleanup is best-effort and must not replace the original definite error,
# even if the provider rejects or loses the DELETE too.
mock_delete = Mock(side_effect=requests.ConnectionError("cleanup failed"))
monkeypatch.setattr(powerpoint.requests, "delete", mock_delete)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "error"
assert "already exists" in result["message"]
mock_delete.assert_called_once_with(
"https://upload.example/session",
timeout=powerpoint._UPLOAD_CANCEL_TIMEOUT_SECONDS,
)
def test_create_only_upload_cancels_session_after_definite_http_failure(monkeypatch):
secret_url = "https://upload.example/session?token=super-secret-value"
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=MockResponse({"uploadUrl": secret_url})),
)
monkeypatch.setattr(
powerpoint.requests,
"put",
Mock(return_value=MockResponse({}, status_code=400, url=secret_url)),
)
mock_delete = Mock(return_value=MockResponse({}, status_code=204))
monkeypatch.setattr(powerpoint.requests, "delete", mock_delete)
with pytest.raises(powerpoint._GraphRequestError) as exc_info:
powerpoint._create_only_upload(b"content", "Deck.pptx", None, None)
assert "super-secret-value" not in str(exc_info.value)
mock_delete.assert_called_once_with(
secret_url, timeout=powerpoint._UPLOAD_CANCEL_TIMEOUT_SECONDS
)
def test_create_presentation_upload_failure_does_not_leak_session_url(monkeypatch):
"""The upload-session URL is a pre-authenticated bearer secret (a token
in its own query string) -- a failed upload must never let that URL
reach the caller through the error message, whether the failure comes
from raise_for_status() or a lower-level connection/timeout error."""
secret_url = "https://upload.example/session?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({"uploadUrl": secret_url}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=MockResponse({}, status_code=500, url=secret_url))
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "indeterminate"
assert result["safe_to_retry"] is False
assert "super-secret-value" not in result["message"]
assert secret_url not in result["message"]
def test_create_presentation_upload_connection_error_does_not_leak_session_url(
monkeypatch,
):
secret_url = "https://upload.example/session?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({"uploadUrl": secret_url}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(
side_effect=requests.ConnectionError(f"Connection refused: {secret_url}")
)
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "indeterminate"
assert result["safe_to_retry"] is False
assert "super-secret-value" not in result["message"]
assert secret_url not in result["message"]
def test_create_only_upload_does_not_chain_secret_bearing_exception(monkeypatch):
"""raise ... from exc would still attach the original, URL-bearing
exception as __cause__ even though the raised message itself is
sanitized -- a future traceback/log/APM capture could surface it.
from None must be used instead, matching onedrive.py's precedent."""
secret_url = "https://upload.example/session?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({"uploadUrl": secret_url}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=MockResponse({}, status_code=500, url=secret_url))
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
with pytest.raises(powerpoint._IndeterminateWriteError) as exc_info:
powerpoint._create_only_upload(b"content", "Deck.pptx", None, None)
assert exc_info.value.__cause__ is None
def test_create_only_upload_connection_error_does_not_chain_exception(monkeypatch):
secret_url = "https://upload.example/session?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({"uploadUrl": secret_url}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(
side_effect=requests.ConnectionError(f"Connection refused: {secret_url}")
)
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
with pytest.raises(powerpoint._IndeterminateWriteError) as exc_info:
powerpoint._create_only_upload(b"content", "Deck.pptx", None, None)
assert exc_info.value.__cause__ is None
def test_create_presentation_uploads_blank_presentation(monkeypatch):
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=MockResponse({"id": "new-item"}, status_code=201))
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "success"
assert result["item"]["id"] == "new-item"
session_call = mock_request.call_args
assert session_call.kwargs["json"] == {
"item": {"@microsoft.graph.conflictBehavior": "fail"}
}
put_call = mock_put.call_args
assert put_call.args[0] == "https://upload.example/session"
assert (
put_call.kwargs["headers"]["Content-Type"] == powerpoint._POWERPOINT_MIME_TYPE
)
assert "Authorization" not in put_call.kwargs.get("headers", {})
# Re-parses as a real, valid (if blank) pptx.
Presentation(io.BytesIO(put_call.kwargs["data"]))
# ---------------------------------------------------------------------------
# read
# ---------------------------------------------------------------------------
def test_get_presentation_text(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[1])
slide.shapes.title.text = "Title A"
slide.placeholders[1].text_frame.text = "Body A"
content = _pptx_bytes(build)
mock_request, mock_get = _mock_download(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "success"
assert result["slides"] == [
{"slide_index": 0, "shapes": ["Title A", "Body A"], "notes": None}
]
assert result["etag"] == '"etag-1"'
assert mock_get.call_args.kwargs["timeout"] == powerpoint._BINARY_TIMEOUT_SECONDS
assert "headers" not in mock_get.call_args.kwargs
def test_get_presentation_text_falls_back_to_authenticated_content_endpoint(
monkeypatch,
):
content = _pptx_bytes()
metadata = _metadata_response(content)
metadata._json_data.pop("@microsoft.graph.downloadUrl")
content_response = MockResponse(content=content)
mock_request = Mock(side_effect=[metadata, content_response])
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_get = Mock()
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "success"
assert mock_get.call_count == 0
content_call = mock_request.call_args_list[1]
assert content_call.kwargs["method"] == "GET"
assert content_call.kwargs["url"].endswith("/drives/drive-1/items/item-1/content")
assert content_call.kwargs["headers"]["Authorization"] == "Bearer test-graph-token"
assert content_call.kwargs["stream"] is True
def test_get_presentation_text_treats_empty_download_url_as_absent(monkeypatch):
content = _pptx_bytes()
metadata = _metadata_response(content)
metadata._json_data["@microsoft.graph.downloadUrl"] = ""
content_response = MockResponse(content=content)
mock_request = Mock(side_effect=[metadata, content_response])
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", Mock())
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "success"
assert (
mock_request.call_args_list[1]
.kwargs["url"]
.endswith("/drives/drive-1/items/item-1/content")
)
def test_presentation_metadata_rejects_non_string_download_url(monkeypatch):
metadata = _metadata_response(b"")
metadata._json_data["@microsoft.graph.downloadUrl"] = 123
monkeypatch.setattr(powerpoint.requests, "request", Mock(return_value=metadata))
with pytest.raises(RuntimeError, match="invalid presentation download URL"):
powerpoint._presentation_metadata("Deck.pptx", None, None)
def test_get_presentation_text_returns_resumable_bounded_pages(monkeypatch):
def build(prs):
for index in range(5):
slide = prs.slides.add_slide(prs.slide_layouts[1])
slide.shapes.title.text = f"Slide {index} " + "x" * 55
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: 430)
cursor = None
slide_indices = []
while True:
result_text = powerpoint.powerpoint_get_presentation_text(
"Deck.pptx", cursor=cursor
)
assert len(result_text) <= 430
result = json.loads(result_text)
assert result["status"] == "success"
slide_indices.extend(slide["slide_index"] for slide in result["slides"])
if not result["truncated"]:
assert result["next_cursor"] is None
break
cursor = result["next_cursor"]
assert slide_indices == list(range(5))
def test_get_presentation_text_skips_oversized_slide_and_continues(
monkeypatch,
):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "x" * 1000
later = prs.slides.add_slide(prs.slide_layouts[6])
later.shapes.add_textbox(
Inches(1), Inches(1), Inches(3), Inches(1)
).text_frame.text = "Later slide"
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: 430)
first_text = powerpoint.powerpoint_get_presentation_text("Deck.pptx")
first = json.loads(first_text)
assert len(first_text) <= 430
assert first["status"] == "success"
assert first["slides"] == []
assert first["omitted_item"] == {
"item_index": 0,
"item_type": "slide",
"reason": "item_exceeds_output_limit",
"output_limit": 430,
}
assert first["truncated"] is True
second = json.loads(
powerpoint.powerpoint_get_presentation_text(
"Deck.pptx", cursor=first["next_cursor"]
)
)
assert second["slides"] == [
{"slide_index": 1, "shapes": ["Later slide"], "notes": None}
]
assert second["truncated"] is False
def test_list_slides_cursor_is_rejected_after_presentation_changes(monkeypatch):
def build(prs):
for index in range(4):
prs.slides.add_slide(prs.slide_layouts[1]).shapes.title.text = str(index)
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: 300)
first = json.loads(powerpoint.powerpoint_list_slides("Deck.pptx"))
assert first["truncated"] is True
_mock_download(monkeypatch, content, etag='"etag-2"')
second = json.loads(
powerpoint.powerpoint_list_slides("Deck.pptx", cursor=first["next_cursor"])
)
assert second["status"] == "conflict"
assert "changed while reading" in second["message"]
def test_get_presentation_text_includes_group_table_and_notes(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(1), Inches(1))
box.text_frame.text = "Top level"
group = slide.shapes.add_group_shape([box])
nested_box = group.shapes.add_textbox(
Inches(2), Inches(2), Inches(1), Inches(1)
)
nested_box.text_frame.text = "Nested"
table_shape = slide.shapes.add_table(
1, 2, Inches(0), Inches(3), Inches(4), Inches(1)
)
table_shape.table.cell(0, 0).text_frame.text = "Cell A"
table_shape.table.cell(0, 1).text_frame.text = "Cell B"
slide.notes_slide.notes_text_frame.text = "Speaker notes"
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "success"
slide_result = result["slides"][0]
assert "Nested" in slide_result["shapes"]
assert "Cell A" in slide_result["shapes"]
assert "Cell B" in slide_result["shapes"]
assert slide_result["notes"] == "Speaker notes"
def test_slide_notes_returns_none_without_creating_notes_slide():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
assert powerpoint._slide_notes(slide) is None
assert not slide.has_notes_slide
def test_get_presentation_text_rejects_non_pptx_content(monkeypatch):
_mock_download(monkeypatch, b"not a pptx file")
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "error"
assert "PowerPoint presentation" in result["message"]
def test_download_rejects_oversized_metadata_before_fetching_content(monkeypatch):
metadata = _metadata_response(b"")
metadata._json_data["size"] = powerpoint._MAX_PRESENTATION_BYTES + 1
mock_request = Mock(return_value=metadata)
mock_get = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
result = json.loads(powerpoint.powerpoint_list_slides("Deck.pptx"))
assert result["status"] == "error"
assert "MB limit" in result["message"]
mock_get.assert_not_called()
def test_download_stream_enforces_byte_limit_when_metadata_is_wrong(monkeypatch):
monkeypatch.setattr(powerpoint, "_MAX_PRESENTATION_BYTES", 10)
metadata = _metadata_response(b"small")
mock_request = Mock(return_value=metadata)
mock_get = Mock(return_value=MockResponse(content=b"x" * 11))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
result = json.loads(powerpoint.powerpoint_list_slides("Deck.pptx"))
assert result["status"] == "error"
assert "download exceeded" in result["message"]
def test_authenticated_download_maps_http_error(monkeypatch):
response = MockResponse(status_code=403)
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=response),
)
with pytest.raises(powerpoint._GraphRequestError, match="HTTP 403"):
powerpoint._download_authenticated_content(
"/drives/drive-1/items/item-1/content", 0
)
def test_authenticated_download_enforces_byte_limit(monkeypatch):
monkeypatch.setattr(powerpoint, "_MAX_PRESENTATION_BYTES", 10)
response = MockResponse(content=b"x" * 11)
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=response),
)
with pytest.raises(ValueError, match="download exceeded"):
powerpoint._download_authenticated_content(
"/drives/drive-1/items/item-1/content", 11
)
def test_authenticated_download_rejects_size_mismatch(monkeypatch):
response = MockResponse(content=b"content")
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=response),
)
with pytest.raises(RuntimeError, match="size changed"):
powerpoint._download_authenticated_content(
"/drives/drive-1/items/item-1/content", len(response.content) + 1
)
def test_authenticated_download_sanitizes_request_failure(monkeypatch):
secret_url = "https://graph.microsoft.com/v1.0/drives/secret?token=secret"
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(side_effect=requests.ConnectionError(secret_url)),
)
with pytest.raises(RuntimeError) as exc_info:
powerpoint._download_authenticated_content(
"/drives/drive-1/items/item-1/content", 0
)
assert "secret" not in str(exc_info.value)
def test_validate_presentation_archive_bounds_expanded_size(monkeypatch):
buffer = io.BytesIO()
with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
archive.writestr("ppt/slides/slide1.xml", b"x" * 100)
monkeypatch.setattr(powerpoint, "_MAX_PRESENTATION_UNCOMPRESSED_BYTES", 50)
with pytest.raises(ValueError, match="expands beyond"):
powerpoint._validate_presentation_archive(buffer.getvalue())
def test_list_slides(monkeypatch):
def build(prs):
prs.slides.add_slide(prs.slide_layouts[1])
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_list_slides("Deck.pptx"))
assert result["status"] == "success"
assert result["slides"][0]["slide_index"] == 0
assert result["slides"][0]["layout_name"] == "Title and Content"
def test_get_slide_text_skips_oversized_shape_and_continues(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "x" * 1000
slide.shapes.add_textbox(
Inches(1), Inches(2), Inches(3), Inches(1)
).text_frame.text = "Later shape"
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: 430)
first_text = powerpoint.powerpoint_get_slide_text("Deck.pptx", 0)
first = json.loads(first_text)
assert len(first_text) <= 430
assert first["status"] == "success"
assert first["shapes"] == []
assert first["omitted_item"]["item_index"] == 0
assert first["omitted_item"]["item_type"] == "shape"
assert first["truncated"] is True
second = json.loads(
powerpoint.powerpoint_get_slide_text(
"Deck.pptx", 0, cursor=first["next_cursor"]
)
)
assert len(second["shapes"]) == 1
assert second["shapes"][0]["shape_index"] == 1
assert second["shapes"][0]["text"] == "Later shape"
assert second["truncated"] is False
def test_get_slide_text_out_of_range(monkeypatch):
content = _pptx_bytes()
_mock_download(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_get_slide_text("Deck.pptx", 0))
assert result["status"] == "error"
assert "out of range" in result["message"]
def test_get_slide_text_rejects_non_int_slide_index(monkeypatch):
"""A direct Python call (e.g. from a test, or any caller bypassing
FastMCP's own schema validation) with a non-int slide_index must get a
clean error response, not an unhandled exception -- and must fail before
ever downloading the presentation."""
mock_request = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(powerpoint.powerpoint_get_slide_text("Deck.pptx", "0"))
assert result["status"] == "error"
assert "slide_index must be an integer" in result["message"]
mock_request.assert_not_called()
def test_list_slide_layouts(monkeypatch):
content = _pptx_bytes()
_mock_download(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_list_slide_layouts("Deck.pptx"))
assert result["status"] == "success"
assert result["layouts"][1] == {"layout_index": 1, "name": "Title and Content"}
# ---------------------------------------------------------------------------
# write
# ---------------------------------------------------------------------------
def test_add_slide_sets_title_and_body(monkeypatch):
content = _pptx_bytes()
mock_request, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_add_slide(
"Deck.pptx", '"etag-1"', title="New Title", body_text="New Body"
)
)
assert result["status"] == "success"
assert result["slide_index"] == 0
session_call = mock_request.call_args_list[1]
assert session_call.kwargs["headers"]["If-Match"] == '"etag-1"'
put_call = mock_put.call_args
uploaded = Presentation(io.BytesIO(put_call.kwargs["data"]))
slide = uploaded.slides[0]
assert slide.shapes.title.text == "New Title"
assert slide.placeholders[1].text_frame.text == "New Body"
assert result["title_applied"] is True
assert result["body_applied"] is True
def test_add_slide_reports_unrequested_content_as_not_applied(monkeypatch):
content = _pptx_bytes()
_mock_versioned_write(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"'))
assert result["status"] == "success"
assert result["title_applied"] is False
assert result["body_applied"] is False
def test_committed_add_slide_result_survives_low_platform_output_cap(monkeypatch):
content = _pptx_bytes()
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
mock_put.return_value = MockResponse(
{
"id": "item-1",
"name": "Deck.pptx",
"description": "provider metadata " * 100,
"thumbnails": [{"large": {"url": "https://example.test/" + "x" * 500}}],
},
status_code=200,
)
max_chars = 80
monkeypatch.setattr(powerpoint, "get_tool_max_output_length", lambda: max_chars)
raw = powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"')
filtered = OutputValueFilter(
max_chars=max_chars, max_fields=100, max_recursion=10
).filter(raw, "powerpoint_add_slide")
assert filtered == raw
assert len(raw) <= max_chars
assert json.loads(filtered)["status"] == "success"
def test_add_slide_rejects_out_of_range_layout(monkeypatch):
_mock_download(monkeypatch, _pptx_bytes())
mock_session_cls = MagicMock()
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
result = json.loads(
powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"', layout_index=999)
)
assert result["status"] == "error"
assert result["message"].startswith("layout_index 999 is out of range")
mock_session_cls.assert_not_called()
def test_add_slide_rejects_stale_etag_before_download(monkeypatch):
content = _pptx_bytes()
mock_request = Mock(return_value=_metadata_response(content, '"etag-new"'))
mock_get = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(powerpoint.requests, "get", mock_get)
result = json.loads(powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-old"'))
assert result["status"] == "conflict"
mock_get.assert_not_called()
@pytest.mark.parametrize(
("kwargs", "missing_field"),
[
({"title": "Not applicable", "layout_index": 6}, "title"),
({"body_text": "Not applicable", "layout_index": 6}, "body_text"),
],
)
def test_add_slide_rejects_content_missing_from_layout(
monkeypatch, kwargs, missing_field
):
mock_request, _ = _mock_download(monkeypatch, _pptx_bytes())
result = json.loads(
powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"', **kwargs)
)
assert result["status"] == "error"
assert missing_field in result["message"]
assert mock_request.call_count == 1
def test_add_slide_rejects_non_int_layout_index(monkeypatch):
mock_request = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(
powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"', layout_index="1")
)
assert result["status"] == "error"
assert "layout_index must be an integer" in result["message"]
mock_request.assert_not_called()
def test_set_shape_text_success(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[1])
slide.shapes.title.text = "Old Title"
content = _pptx_bytes(build)
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, 0, "New Title", '"etag-1"')
)
assert result["status"] == "success"
put_call = mock_put.call_args
uploaded = Presentation(io.BytesIO(put_call.kwargs["data"]))
assert uploaded.slides[0].shapes.title.text == "New Title"
def test_set_shape_text_rejects_non_int_indices(monkeypatch):
mock_request = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", "0", 0, "text", '"etag-1"')
)
assert result["status"] == "error"
assert "slide_index must be an integer" in result["message"]
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, "0", "text", '"etag-1"')
)
assert result["status"] == "error"
assert "shape_index must be an integer" in result["message"]
mock_request.assert_not_called()
def test_set_shape_text_rejects_shape_without_text_frame(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
from pptx.enum.shapes import MSO_CONNECTOR
slide.shapes.add_connector(
MSO_CONNECTOR.STRAIGHT, Inches(0), Inches(0), Inches(1), Inches(1)
)
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, 0, "text", '"etag-1"')
)
assert result["status"] == "error"
assert "no text frame" in result["message"]
def test_text_frame_has_dynamic_content_detects_hyperlink():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Click me"
run.hyperlink.address = "https://example.com"
assert powerpoint._text_frame_has_dynamic_content(box.text_frame)
def test_text_frame_has_dynamic_content_detects_mouseover_hyperlink():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Hover me"
run_properties = run._r.get_or_add_rPr()
etree.SubElement(run_properties, qn("a:hlinkMouseOver"))
assert powerpoint._text_frame_has_dynamic_content(box.text_frame)
def test_text_frame_distinct_run_formatting_is_detected():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
bold_run = box.text_frame.paragraphs[0].add_run()
bold_run.text = "Bold"
bold_run.font.bold = True
box.text_frame.paragraphs[0].add_run().text = "Plain"
assert powerpoint._text_frame_has_distinct_run_formatting(box.text_frame)
def test_text_frame_equivalent_run_formatting_is_not_rejected():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
for text in ("First", "Second"):
run = box.text_frame.paragraphs[0].add_run()
run.text = text
run.font.bold = True
run.font.size = Pt(24)
assert not powerpoint._text_frame_has_distinct_run_formatting(box.text_frame)
def test_text_frame_distinct_line_break_formatting_is_detected():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "First\vSecond"
for run in box.text_frame.paragraphs[0].runs:
run.font.size = Pt(24)
line_break = box.text_frame.paragraphs[0]._p.find(qn("a:br"))
line_break.get_or_add_rPr().set("sz", "4000")
assert powerpoint._text_frame_has_distinct_run_formatting(box.text_frame)
def test_text_frame_has_dynamic_content_false_for_plain_text():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "Plain text"
assert not powerpoint._text_frame_has_dynamic_content(box.text_frame)
def test_set_shape_text_rejects_shape_with_hyperlink(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Click me"
run.hyperlink.address = "https://example.com"
content = _pptx_bytes(build)
_mock_download(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, 0, "New text", '"etag-1"')
)
assert result["status"] == "error"
assert "hyperlink" in result["message"]
def test_delete_slide_tool_uploads_updated_presentation(monkeypatch):
def build(prs):
prs.slides.add_slide(prs.slide_layouts[1]).shapes.title.text = "A"
prs.slides.add_slide(prs.slide_layouts[1]).shapes.title.text = "B"
content = _pptx_bytes(build)
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(powerpoint.powerpoint_delete_slide("Deck.pptx", 0, '"etag-1"'))
assert result["status"] == "success"
put_call = mock_put.call_args
uploaded = Presentation(io.BytesIO(put_call.kwargs["data"]))
assert [s.shapes.title.text for s in uploaded.slides] == ["B"]
def test_delete_slide_tool_rejects_non_int_slide_index(monkeypatch):
mock_request = Mock()
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(
powerpoint.powerpoint_delete_slide("Deck.pptx", "0", '"etag-1"')
)
assert result["status"] == "error"
assert "slide_index must be an integer" in result["message"]
mock_request.assert_not_called()
def test_upload_presentation_rejects_oversized_content(monkeypatch):
presentation = Presentation()
monkeypatch.setattr(powerpoint, "_MAX_PRESENTATION_BYTES", 10)
with pytest.raises(ValueError, match="MB limit"):
powerpoint._upload_presentation(
presentation, "Deck.pptx", None, None, '"etag-1"'
)
def test_upload_presentation_conditionally_creates_upload_session(monkeypatch):
"""Every replacement uses If-Match when its upload session is created."""
presentation = Presentation()
monkeypatch.setattr(powerpoint, "_UPLOAD_SESSION_CHUNK_BYTES", 10)
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
put_calls: list[MockResponse] = []
def fake_put(url, *, data, headers, timeout):
put_calls.append((url, data, headers))
range_part, total_str = (
headers["Content-Range"].removeprefix("bytes ").split("/")
)
_, end_str = range_part.split("-")
is_last = int(end_str) + 1 == int(total_str)
if is_last:
return MockResponse({"id": "item-1"}, status_code=200)
return MockResponse(
{"nextExpectedRanges": [f"{int(end_str) + 1}-"]}, status_code=202
)
mock_session_put = Mock(side_effect=fake_put)
mock_session_cls = MagicMock()
mock_session_cls.return_value.__enter__.return_value.put = mock_session_put
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
item = powerpoint._upload_presentation(
presentation, "Deck.pptx", None, None, '"etag-1"'
)
assert item["id"] == "item-1"
assert len(put_calls) > 1
assert mock_request.call_args.kwargs["headers"]["If-Match"] == '"etag-1"'
assert "Authorization" not in put_calls[0][2]
full_content = b"".join(call[1] for call in put_calls)
Presentation(io.BytesIO(full_content))
def test_upload_presentation_session_rejects_when_no_upload_url(monkeypatch):
mock_request = Mock(return_value=MockResponse({}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
with pytest.raises(RuntimeError, match="did not return an upload session URL"):
powerpoint._upload_presentation_session(
b"content", "Deck.pptx", None, None, '"etag-1"'
)
def test_upload_presentation_session_failure_does_not_leak_session_url(monkeypatch):
secret_url = "https://upload.example/session?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({"uploadUrl": secret_url}))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=MockResponse({}, status_code=500, url=secret_url))
mock_session_cls = MagicMock()
mock_http = mock_session_cls.return_value.__enter__.return_value
mock_http.put = mock_put
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
with pytest.raises(powerpoint._IndeterminateWriteError) as exc_info:
powerpoint._upload_presentation_session(
b"content" * 100_000, "Deck.pptx", None, None, '"etag-1"'
)
assert exc_info.value.__cause__ is None
assert "super-secret-value" not in str(exc_info.value)
mock_http.delete.assert_not_called()
def test_upload_session_cancels_after_definite_nonfinal_failure(monkeypatch):
secret_url = "https://upload.example/session?token=super-secret-value"
monkeypatch.setattr(powerpoint, "_UPLOAD_SESSION_CHUNK_BYTES", 5)
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=MockResponse({"uploadUrl": secret_url})),
)
responses = iter(
[
MockResponse({"nextExpectedRanges": ["5-"]}, status_code=202),
MockResponse({}, status_code=400, url=secret_url),
]
)
mock_session_cls = MagicMock()
mock_http = mock_session_cls.return_value.__enter__.return_value
mock_http.put = Mock(side_effect=lambda *a, **k: next(responses))
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
with pytest.raises(powerpoint._GraphRequestError) as exc_info:
powerpoint._upload_presentation_session(
b"0123456789", "Deck.pptx", None, None, '"etag-1"'
)
assert "super-secret-value" not in str(exc_info.value)
mock_http.delete.assert_called_once_with(
secret_url, timeout=powerpoint._UPLOAD_CANCEL_TIMEOUT_SECONDS
)
def test_upload_session_cancels_after_invalid_progress(monkeypatch):
upload_url = "https://upload.example/session"
monkeypatch.setattr(powerpoint, "_UPLOAD_SESSION_CHUNK_BYTES", 5)
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(return_value=MockResponse({"uploadUrl": upload_url})),
)
mock_session_cls = MagicMock()
mock_http = mock_session_cls.return_value.__enter__.return_value
mock_http.put = Mock(
return_value=MockResponse({"nextExpectedRanges": []}, status_code=202)
)
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
with pytest.raises(RuntimeError, match="empty.*progress"):
powerpoint._upload_presentation_session(
b"0123456789", "Deck.pptx", None, None, '"etag-1"'
)
mock_http.delete.assert_called_once_with(
upload_url, timeout=powerpoint._UPLOAD_CANCEL_TIMEOUT_SECONDS
)
def test_upload_session_follows_server_reported_next_offset(monkeypatch):
monkeypatch.setattr(powerpoint, "_UPLOAD_SESSION_CHUNK_BYTES", 5)
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
responses = iter(
[
MockResponse({"nextExpectedRanges": ["3-"]}, status_code=202),
MockResponse({"nextExpectedRanges": ["8-"]}, status_code=202),
MockResponse({"id": "item-1"}, status_code=200),
]
)
mock_put = Mock(side_effect=lambda *a, **k: next(responses))
mock_session_cls = MagicMock()
mock_session_cls.return_value.__enter__.return_value.put = mock_put
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
item = powerpoint._upload_presentation_session(
b"0123456789", "Deck.pptx", None, None, '"etag-1"'
)
assert item["id"] == "item-1"
assert [
call.kwargs["headers"]["Content-Range"] for call in mock_put.call_args_list
] == [
"bytes 0-4/10",
"bytes 3-7/10",
"bytes 8-9/10",
]
def test_add_slide_maps_upload_precondition_failure_to_conflict(monkeypatch):
content = _pptx_bytes()
responses = iter(
[
_metadata_response(content),
MockResponse({"error": {"code": "preconditionFailed"}}, status_code=412),
]
)
monkeypatch.setattr(
powerpoint.requests,
"request",
Mock(side_effect=lambda *a, **k: next(responses)),
)
monkeypatch.setattr(
powerpoint.requests, "get", Mock(return_value=MockResponse(content=content))
)
result = json.loads(powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"'))
assert result["status"] == "conflict"
def test_add_slide_maps_final_fragment_precondition_failure_to_conflict(monkeypatch):
content = _pptx_bytes()
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
mock_put.return_value = MockResponse(
{"error": {"code": "preconditionFailed"}}, status_code=412
)
result = json.loads(powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"'))
assert result["status"] == "conflict"
assert "changed" in result["message"]
def test_add_slide_reports_final_connection_loss_as_indeterminate(monkeypatch):
content = _pptx_bytes()
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
mock_put.side_effect = requests.ConnectionError(
"lost response from https://upload.example/session?secret=token"
)
result = json.loads(powerpoint.powerpoint_add_slide("Deck.pptx", '"etag-1"'))
assert result["status"] == "indeterminate"
assert result["safe_to_retry"] is False
assert "secret=token" not in result["message"]
# ---------------------------------------------------------------------------
# error propagation
# ---------------------------------------------------------------------------
def test_graph_request_http_error_does_not_leak_redirect_url(monkeypatch):
"""Graph's /content GET redirects to a preauthenticated download URL --
if that final request fails, requests' own HTTPError.__str__ embeds
that signed URL as response.url. _graph_request must never surface
that string, whether directly in the raised message or as the
chained exception's __cause__ (a future traceback/log/APM capture
could still surface a __cause__ even with a clean top-level message)."""
secret_url = "https://blob.example/deck.pptx?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({}, status_code=403, url=secret_url))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
with pytest.raises(powerpoint._GraphRequestError) as exc_info:
powerpoint._graph_request("GET", "/me/drive/root:/Deck.pptx:/content")
assert "super-secret-value" not in str(exc_info.value)
assert secret_url not in str(exc_info.value)
assert exc_info.value.__cause__ is None
def test_graph_request_does_not_forward_secret_from_error_body(monkeypatch):
secret_url = "https://blob.example/deck.pptx?sig=super-secret-value"
response = MockResponse(
{"error": {"code": "accessDenied", "message": secret_url}},
status_code=403,
)
monkeypatch.setattr(powerpoint.requests, "request", Mock(return_value=response))
with pytest.raises(powerpoint._GraphRequestError) as exc_info:
powerpoint._graph_request("GET", "/me/drive/root:/Deck.pptx:/content")
assert "accessDenied" in str(exc_info.value)
assert "super-secret-value" not in str(exc_info.value)
def test_graph_request_connection_error_does_not_leak_redirect_url(monkeypatch):
"""The initial requests.request() call itself (not just raise_for_status())
can fail at the connection layer (timeout, reset, TLS error) after
following the same redirect -- requests.RequestException's own str()
embeds the URL just like HTTPError's does, so this path must be
sanitized too."""
secret_url = "https://blob.example/deck.pptx?token=super-secret-value"
mock_request = Mock(
side_effect=requests.ConnectionError(f"Connection refused: {secret_url}")
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
with pytest.raises(RuntimeError) as exc_info:
powerpoint._graph_request("GET", "/me/drive/root:/Deck.pptx:/content")
assert "super-secret-value" not in str(exc_info.value)
assert exc_info.value.__cause__ is None
def test_get_presentation_text_reports_download_failure_without_leaking_url(
monkeypatch,
):
secret_url = "https://blob.example/deck.pptx?token=super-secret-value"
mock_request = Mock(return_value=MockResponse({}, status_code=403, url=secret_url))
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "error"
assert "super-secret-value" not in result["message"]
assert secret_url not in result["message"]
def test_slide_notes_returns_none_when_notes_placeholder_is_missing():
"""notes_text_frame can be None even when has_notes_slide is True --
e.g. the notes placeholder was deleted from the notes slide while the
notes-slide XML part itself survives."""
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
notes_slide = slide.notes_slide # creates the notes slide
notes_placeholder = notes_slide.notes_placeholder
notes_placeholder._element.getparent().remove(notes_placeholder._element)
assert notes_slide.notes_text_frame is None
assert powerpoint._slide_notes(slide) is None
def _non_json_success_response() -> Mock:
"""A 2xx response whose body isn't valid JSON -- unlike MockResponse,
whose .json() always returns a stored dict regardless of `content`,
this actually raises like a real empty/non-JSON body would."""
response = Mock()
response.status_code = 200
response.raise_for_status = Mock(return_value=None)
response.json = Mock(side_effect=ValueError("Expecting value"))
return response
def test_upload_presentation_session_marks_non_json_final_response_indeterminate(
monkeypatch,
):
"""A 2xx final response without an item may follow a committed write."""
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=_non_json_success_response())
mock_session_cls = MagicMock()
mock_session_cls.return_value.__enter__.return_value.put = mock_put
monkeypatch.setattr(powerpoint.requests, "Session", mock_session_cls)
with pytest.raises(powerpoint._IndeterminateWriteError, match="did not return"):
powerpoint._upload_presentation_session(
b"content", "Deck.pptx", None, None, '"etag-1"'
)
def test_create_only_upload_handles_non_json_final_response(monkeypatch):
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
mock_put = Mock(return_value=_non_json_success_response())
monkeypatch.setattr(powerpoint.requests, "put", mock_put)
with pytest.raises(powerpoint._IndeterminateWriteError, match="did not confirm"):
powerpoint._create_only_upload(b"content", "Deck.pptx", None, None)
def test_create_presentation_reports_non_json_final_response_as_indeterminate(
monkeypatch,
):
mock_request = Mock(
return_value=MockResponse({"uploadUrl": "https://upload.example/session"})
)
monkeypatch.setattr(powerpoint.requests, "request", mock_request)
monkeypatch.setattr(
powerpoint.requests, "put", Mock(return_value=_non_json_success_response())
)
result = json.loads(powerpoint.powerpoint_create_presentation("Deck.pptx"))
assert result["status"] == "indeterminate"
assert result["safe_to_retry"] is False
assert "check whether the file exists" in result["message"]
def test_replace_text_frame_text_preserves_run_formatting():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Old"
run.font.bold = True
run.font.size = Pt(24)
powerpoint._replace_text_frame_text(box.text_frame, "New")
new_run = box.text_frame.paragraphs[0].runs[0]
assert new_run.text == "New"
assert new_run.font.bold is True
assert new_run.font.size == Pt(24)
def test_replace_text_frame_text_preserves_paragraph_alignment():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "Old"
box.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
powerpoint._replace_text_frame_text(box.text_frame, "New")
assert box.text_frame.paragraphs[0].alignment == PP_ALIGN.CENTER
assert box.text_frame.paragraphs[0].text == "New"
def test_replace_text_frame_text_handles_paragraph_count_change():
"""New paragraphs inherit the final old paragraph's formatting."""
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "Only line"
box.text_frame.paragraphs[0].runs[0].font.bold = True
box.text_frame.paragraphs[0].runs[0].font.size = Pt(24)
box.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
powerpoint._replace_text_frame_text(box.text_frame, "Line one\nLine two")
paragraphs = box.text_frame.paragraphs
assert [p.text for p in paragraphs] == ["Line one", "Line two"]
for paragraph in paragraphs:
assert paragraph.alignment == PP_ALIGN.CENTER
assert paragraph.runs[0].font.bold is True
assert paragraph.runs[0].font.size == Pt(24)
def test_replace_text_frame_text_preserves_formatting_across_soft_break():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Old"
run.font.bold = True
run.font.size = Pt(24)
powerpoint._replace_text_frame_text(box.text_frame, "Line one\vLine two")
runs = box.text_frame.paragraphs[0].runs
assert [run.text for run in runs] == ["Line one", "Line two"]
for result_run in runs:
assert result_run.font.bold is True
assert result_run.font.size == Pt(24)
line_break = box.text_frame.paragraphs[0]._p.find(qn("a:br"))
line_break_properties = line_break.find(qn("a:rPr"))
assert line_break_properties is not None
assert line_break_properties.get("b") == "1"
assert line_break_properties.get("sz") == "2400"
def test_replace_text_frame_text_preserves_end_paragraph_formatting():
presentation = Presentation()
slide = presentation.slides.add_slide(presentation.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
box.text_frame.text = "Old"
end_properties = box.text_frame.paragraphs[0]._p.get_or_add_endParaRPr()
end_properties.set("b", "1")
end_properties.set("sz", "3200")
powerpoint._replace_text_frame_text(box.text_frame, "New")
result = box.text_frame.paragraphs[0]._p.find(qn("a:endParaRPr"))
assert result is not None
assert result.get("b") == "1"
assert result.get("sz") == "3200"
def test_set_shape_text_preserves_formatting(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
run = box.text_frame.paragraphs[0].add_run()
run.text = "Old"
run.font.bold = True
content = _pptx_bytes(build)
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, 0, "New", '"etag-1"')
)
assert result["status"] == "success"
put_call = mock_put.call_args
uploaded = Presentation(io.BytesIO(put_call.kwargs["data"]))
run = uploaded.slides[0].shapes[0].text_frame.paragraphs[0].runs[0]
assert run.text == "New"
assert run.font.bold is True
def test_set_shape_text_preserves_formatting_across_structural_breaks(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
paragraph = box.text_frame.paragraphs[0]
paragraph.alignment = PP_ALIGN.CENTER
run = paragraph.add_run()
run.text = "Old"
run.font.bold = True
run.font.size = Pt(24)
end_properties = paragraph._p.get_or_add_endParaRPr()
end_properties.set("lang", "en-US")
content = _pptx_bytes(build)
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text(
"Deck.pptx", 0, 0, "Line one\nLine two\vLine three", '"etag-1"'
)
)
assert result["status"] == "success"
uploaded = Presentation(io.BytesIO(mock_put.call_args.kwargs["data"]))
paragraphs = uploaded.slides[0].shapes[0].text_frame.paragraphs
assert [paragraph.text for paragraph in paragraphs] == [
"Line one",
"Line two\vLine three",
]
for paragraph in paragraphs:
assert paragraph.alignment == PP_ALIGN.CENTER
for run in paragraph.runs:
assert run.font.bold is True
assert run.font.size == Pt(24)
end_properties = paragraph._p.find(qn("a:endParaRPr"))
assert end_properties is not None
assert end_properties.get("lang") == "en-US"
line_break = paragraphs[1]._p.find(qn("a:br"))
line_break_properties = line_break.find(qn("a:rPr"))
assert line_break_properties is not None
assert line_break_properties.get("b") == "1"
assert line_break_properties.get("sz") == "2400"
def test_set_shape_text_allows_equivalently_formatted_runs(monkeypatch):
def build(prs):
slide = prs.slides.add_slide(prs.slide_layouts[6])
box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(3), Inches(1))
for value in ("Old ", "text"):
run = box.text_frame.paragraphs[0].add_run()
run.text = value
run.font.bold = True
run.font.size = Pt(24)
content = _pptx_bytes(build)
_, _, mock_put = _mock_versioned_write(monkeypatch, content)
result = json.loads(
powerpoint.powerpoint_set_shape_text("Deck.pptx", 0, 0, "New", '"etag-1"')
)
assert result["status"] == "success"
uploaded = Presentation(io.BytesIO(mock_put.call_args.kwargs["data"]))
runs = uploaded.slides[0].shapes[0].text_frame.paragraphs[0].runs
assert len(runs) == 1
assert runs[0].text == "New"
assert runs[0].font.bold is True
assert runs[0].font.size == Pt(24)
def test_missing_auth_token_is_reported(monkeypatch):
monkeypatch.delenv("AUTH_TOKEN", raising=False)
result = json.loads(powerpoint.powerpoint_get_presentation_text("Deck.pptx"))
assert result["status"] == "error"
assert "AUTH_TOKEN" in result["message"]