wehub-resource-sync
2330 lines
71 KiB
Python
2330 lines
71 KiB
Python
import asyncio
|
|
import io
|
|
import os
|
|
import struct
|
|
import zipfile
|
|
import xml.etree.ElementTree as ET
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from templates import fonts_and_slides_preview
|
|
from templates import pptx_font_utils
|
|
from models.sql.font_upload import FontUpload
|
|
|
|
|
|
class DummyLogger:
|
|
def info(self, *_args, **_kwargs):
|
|
return None
|
|
|
|
def warning(self, *_args, **_kwargs):
|
|
return None
|
|
|
|
|
|
_SIZE_UNSET = object()
|
|
|
|
|
|
class DummyUploadFile:
|
|
def __init__(
|
|
self,
|
|
filename: str,
|
|
content: bytes = b"font",
|
|
size: int | None | object = _SIZE_UNSET,
|
|
) -> None:
|
|
self.filename = filename
|
|
self._content = content
|
|
self.size = len(content) if size is _SIZE_UNSET else size
|
|
|
|
async def read(self) -> bytes:
|
|
return self._content
|
|
|
|
|
|
async def _run_sync_in_test(func, *args, **kwargs):
|
|
return func(*args, **kwargs)
|
|
|
|
|
|
def _fake_corrupted_pptx_bytes() -> bytes:
|
|
return b"this is not a valid powerpoint zip package"
|
|
|
|
|
|
def _fake_pptx_bytes(slide_count: int) -> bytes:
|
|
buffer = io.BytesIO()
|
|
slide_ids = "\n".join(
|
|
f'<p:sldId id="{255 + index}" r:id="rId{index}" />'
|
|
for index in range(1, slide_count + 1)
|
|
)
|
|
rels = "\n".join(
|
|
f'<Relationship Id="rId{index}" '
|
|
'Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" '
|
|
f'Target="slides/slide{index}.xml" />'
|
|
for index in range(1, slide_count + 1)
|
|
)
|
|
overrides = "\n".join(
|
|
f'<Override PartName="/ppt/slides/slide{index}.xml" '
|
|
'ContentType="application/vnd.openxmlformats-officedocument.presentationml.slide+xml" />'
|
|
for index in range(1, slide_count + 1)
|
|
)
|
|
with zipfile.ZipFile(buffer, "w") as archive:
|
|
archive.writestr(
|
|
"[Content_Types].xml",
|
|
f"""\
|
|
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
|
|
{overrides}
|
|
</Types>""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/presentation.xml",
|
|
f"""\
|
|
<p:presentation xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:sldIdLst>
|
|
{slide_ids}
|
|
</p:sldIdLst>
|
|
</p:presentation>""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/_rels/presentation.xml.rels",
|
|
f"""\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
{rels}
|
|
</Relationships>""",
|
|
)
|
|
for index in range(1, slide_count + 1):
|
|
archive.writestr(f"ppt/slides/slide{index}.xml", "<p:sld />")
|
|
archive.writestr(f"ppt/slides/_rels/slide{index}.xml.rels", "<rels />")
|
|
return buffer.getvalue()
|
|
|
|
|
|
def test_build_google_fonts_stylesheet_url_includes_regular_and_bold_weights():
|
|
assert (
|
|
pptx_font_utils.build_google_fonts_stylesheet_url("Open Sans")
|
|
== "https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;700&display=swap"
|
|
)
|
|
|
|
|
|
def test_normalize_font_family_name_strips_localized_bold_token():
|
|
assert pptx_font_utils.normalize_font_family_name("Arial Gras") == "Arial"
|
|
|
|
|
|
def test_normalize_font_family_name_preserves_width_tokens():
|
|
assert (
|
|
pptx_font_utils.normalize_font_family_name("Latin Condensed")
|
|
== "Latin Condensed"
|
|
)
|
|
assert (
|
|
pptx_font_utils.normalize_font_family_name("Roboto Condensed Bold")
|
|
== "Roboto Condensed"
|
|
)
|
|
assert (
|
|
pptx_font_utils.normalize_font_family_name("Arial Narrow Bold")
|
|
== "Arial Narrow"
|
|
)
|
|
|
|
|
|
def test_extract_font_from_eot_uses_header_font_data_offset(tmp_path):
|
|
embedded_font = b"\x00\x01\x00\x00valid-font-data"
|
|
header_body = b"metadata-before-font\x00\x01\x00\x00not-the-font"
|
|
eot_size = 8 + len(header_body) + len(embedded_font)
|
|
font_data_size = len(embedded_font)
|
|
eot_path = tmp_path / "font.fntdata"
|
|
eot_path.write_bytes(
|
|
struct.pack("<II", eot_size, font_data_size) + header_body + embedded_font
|
|
)
|
|
|
|
assert pptx_font_utils.extract_font_from_eot(eot_path) == embedded_font
|
|
|
|
|
|
def test_check_fonts_in_pptx_rejects_100mb_file_from_upload_size():
|
|
upload = DummyUploadFile(
|
|
"deck.pptx",
|
|
content=b"",
|
|
size=fonts_and_slides_preview.MAX_FONT_CHECK_UPLOAD_SIZE_BYTES,
|
|
)
|
|
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
asyncio.run(fonts_and_slides_preview.check_fonts_in_pptx_handler(upload))
|
|
|
|
assert exc_info.value.status_code == 413
|
|
assert exc_info.value.detail == "File size must be less than 100MB."
|
|
|
|
|
|
def test_check_fonts_in_pptx_rejects_oversize_after_read_when_size_missing(
|
|
monkeypatch,
|
|
):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview, "MAX_FONT_CHECK_UPLOAD_SIZE_BYTES", 4
|
|
)
|
|
upload = DummyUploadFile("deck.pptx", content=b"abcd", size=None)
|
|
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
asyncio.run(fonts_and_slides_preview.check_fonts_in_pptx_handler(upload))
|
|
|
|
assert exc_info.value.status_code == 413
|
|
assert exc_info.value.detail == "File size must be less than 100MB."
|
|
|
|
|
|
def test_check_fonts_in_pptx_rejects_corrupted_pptx():
|
|
upload = DummyUploadFile("corrupted.pptx", content=_fake_corrupted_pptx_bytes())
|
|
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
asyncio.run(fonts_and_slides_preview.check_fonts_in_pptx_handler(upload))
|
|
|
|
assert exc_info.value.status_code == 400
|
|
assert exc_info.value.detail == fonts_and_slides_preview.INVALID_PPTX_UPLOAD_ERROR
|
|
|
|
|
|
def test_upload_fonts_and_preview_rejects_corrupted_pptx():
|
|
upload = DummyUploadFile("corrupted.pptx", content=_fake_corrupted_pptx_bytes())
|
|
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
asyncio.run(
|
|
fonts_and_slides_preview.upload_fonts_and_preview_handler(
|
|
pptx_file=upload,
|
|
font_files=[],
|
|
original_font_names=[],
|
|
get_slide_images=True,
|
|
)
|
|
)
|
|
|
|
assert exc_info.value.status_code == 400
|
|
assert exc_info.value.detail == fonts_and_slides_preview.INVALID_PPTX_UPLOAD_ERROR
|
|
|
|
|
|
def test_template_preview_slide_cap_and_pptx_trim(tmp_path):
|
|
pptx_path = tmp_path / "deck.pptx"
|
|
pptx_path.write_bytes(_fake_pptx_bytes(52))
|
|
|
|
assert fonts_and_slides_preview._resolve_template_preview_slide_cap(None) == 50
|
|
assert fonts_and_slides_preview._resolve_template_preview_slide_cap(100) == 50
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
fonts_and_slides_preview._resolve_template_preview_slide_cap(0)
|
|
assert exc_info.value.status_code == 400
|
|
|
|
trimmed_path = fonts_and_slides_preview._trim_pptx_to_max_slides(
|
|
str(pptx_path),
|
|
50,
|
|
str(tmp_path),
|
|
DummyLogger(),
|
|
)
|
|
|
|
assert trimmed_path != str(pptx_path)
|
|
with zipfile.ZipFile(trimmed_path) as archive:
|
|
assert "ppt/slides/slide50.xml" in archive.namelist()
|
|
assert "ppt/slides/slide51.xml" not in archive.namelist()
|
|
presentation_xml = ET.fromstring(archive.read("ppt/presentation.xml"))
|
|
slide_ids = presentation_xml.findall(
|
|
".//p:sldId", fonts_and_slides_preview.PPT_NS
|
|
)
|
|
assert len(slide_ids) == 50
|
|
rels_xml = ET.fromstring(archive.read("ppt/_rels/presentation.xml.rels"))
|
|
assert rels_xml.find(
|
|
".//*[@Id='rId51']",
|
|
) is None
|
|
content_types = archive.read("[Content_Types].xml").decode()
|
|
assert "/ppt/slides/slide51.xml" not in content_types
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_upload_fonts_and_preview_uses_trimmed_pptx_for_processing(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
captured = {}
|
|
slide_path = tmp_path / "slide_1.png"
|
|
slide_path.write_bytes(b"png")
|
|
|
|
def assert_slide_count(path, expected_count):
|
|
with zipfile.ZipFile(path) as archive:
|
|
presentation_xml = ET.fromstring(archive.read("ppt/presentation.xml"))
|
|
slide_ids = presentation_xml.findall(
|
|
".//p:sldId", fonts_and_slides_preview.PPT_NS
|
|
)
|
|
assert len(slide_ids) == expected_count
|
|
assert "ppt/slides/slide50.xml" in archive.namelist()
|
|
assert "ppt/slides/slide51.xml" not in archive.namelist()
|
|
|
|
def fake_font_variants(path):
|
|
captured["font_variant_pptx_path"] = path
|
|
assert_slide_count(path, 50)
|
|
return {}
|
|
|
|
async def fake_upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path,
|
|
temp_dir,
|
|
original_filename,
|
|
font_files,
|
|
original_font_names,
|
|
logger,
|
|
session_dir,
|
|
upload_fonts=True,
|
|
google_font_replacements=None,
|
|
):
|
|
del temp_dir, original_filename, font_files, original_font_names, logger
|
|
del session_dir, upload_fonts, google_font_replacements
|
|
captured["font_processing_pptx_path"] = pptx_path
|
|
assert_slide_count(pptx_path, 50)
|
|
return set(), {}, {}, [], pptx_path, [], [], {}, [], {}
|
|
|
|
async def fake_create_slide_previews(
|
|
modified_pptx_path,
|
|
temp_dir,
|
|
font_paths_for_install,
|
|
font_mapping,
|
|
explicit_font_aliases,
|
|
protected_font_names,
|
|
max_slides,
|
|
logger,
|
|
session_dir,
|
|
font_stylesheet_urls=None,
|
|
):
|
|
del temp_dir, font_paths_for_install, font_mapping, explicit_font_aliases
|
|
del protected_font_names, logger, session_dir
|
|
assert font_stylesheet_urls == []
|
|
captured["preview_pptx_path"] = modified_pptx_path
|
|
assert max_slides == 50
|
|
assert_slide_count(modified_pptx_path, 50)
|
|
return [str(slide_path)]
|
|
|
|
async def fake_upload_presentations(modified_pptx_path, logger, session_dir):
|
|
del logger, session_dir
|
|
captured["uploaded_pptx_path"] = modified_pptx_path
|
|
assert_slide_count(modified_pptx_path, 50)
|
|
return modified_pptx_path
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
fake_font_variants,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"upload_fonts_and_fix_fonts_in_pptx",
|
|
fake_upload_fonts_and_fix_fonts_in_pptx,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"create_slide_previews",
|
|
fake_create_slide_previews,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"upload_presentations",
|
|
fake_upload_presentations,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_public_urls_for_local_paths",
|
|
lambda paths: list(paths),
|
|
)
|
|
|
|
response = await fonts_and_slides_preview.upload_fonts_and_preview_handler(
|
|
pptx_file=DummyUploadFile("deck.pptx", content=_fake_pptx_bytes(52)),
|
|
font_files=[],
|
|
original_font_names=[],
|
|
temp_dir=str(tmp_path),
|
|
)
|
|
|
|
assert captured["font_variant_pptx_path"].endswith("presentation-first-50.pptx")
|
|
assert captured["font_processing_pptx_path"] == captured["font_variant_pptx_path"]
|
|
assert captured["preview_pptx_path"] == captured["font_variant_pptx_path"]
|
|
assert captured["uploaded_pptx_path"] == captured["font_variant_pptx_path"]
|
|
assert response.pptx_url == captured["font_variant_pptx_path"]
|
|
assert response.modified_pptx_url == captured["font_variant_pptx_path"]
|
|
assert response.slide_image_urls == [str(slide_path)]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_upload_fonts_and_preview_passes_google_fonts_to_html_preview(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
captured = {}
|
|
slide_path = tmp_path / "slide_1.png"
|
|
slide_path.write_bytes(b"png")
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Open Sans": {"bold"}},
|
|
)
|
|
|
|
async def fake_upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path,
|
|
temp_dir,
|
|
original_filename,
|
|
font_files,
|
|
original_font_names,
|
|
logger,
|
|
session_dir,
|
|
upload_fonts=True,
|
|
google_font_replacements=None,
|
|
):
|
|
del temp_dir, original_filename, font_files, original_font_names
|
|
del logger, session_dir, upload_fonts, google_font_replacements
|
|
return {"Open Sans"}, {}, {}, [], pptx_path, [], [], {}, [], {}
|
|
|
|
async def fake_check_google_font_availability(font_name, variants=None):
|
|
captured["checked_font"] = font_name
|
|
captured["checked_variants"] = variants
|
|
return True
|
|
|
|
async def fake_create_slide_previews(
|
|
modified_pptx_path,
|
|
temp_dir,
|
|
font_paths_for_install,
|
|
font_mapping,
|
|
explicit_font_aliases,
|
|
protected_font_names,
|
|
max_slides,
|
|
logger,
|
|
session_dir,
|
|
font_stylesheet_urls=None,
|
|
):
|
|
del modified_pptx_path, temp_dir, font_paths_for_install, font_mapping
|
|
del explicit_font_aliases, protected_font_names, max_slides, logger
|
|
del session_dir
|
|
captured["font_stylesheet_urls"] = font_stylesheet_urls
|
|
return [str(slide_path)]
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"upload_fonts_and_fix_fonts_in_pptx",
|
|
fake_upload_fonts_and_fix_fonts_in_pptx,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"check_google_font_availability",
|
|
fake_check_google_font_availability,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"create_slide_previews",
|
|
fake_create_slide_previews,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_public_urls_for_local_paths",
|
|
lambda paths: list(paths),
|
|
)
|
|
|
|
response = await fonts_and_slides_preview.upload_fonts_and_preview_handler(
|
|
pptx_file=DummyUploadFile("deck.pptx", content=_fake_pptx_bytes(1)),
|
|
font_files=[],
|
|
original_font_names=[],
|
|
upload_presentation=False,
|
|
temp_dir=str(tmp_path),
|
|
)
|
|
|
|
expected_url = (
|
|
"https://fonts.googleapis.com/css2"
|
|
"?family=Open+Sans:wght@400;700&display=swap"
|
|
)
|
|
assert captured["checked_font"] == "Open Sans"
|
|
assert captured["checked_variants"] == ["bold"]
|
|
assert captured["font_stylesheet_urls"] == [expected_url]
|
|
assert response.fonts == {"Open Sans": expected_url}
|
|
assert response.slide_image_urls == [str(slide_path)]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_upload_fonts_and_preview_replaces_pptx_fonts_with_selected_google_fonts(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
captured = {}
|
|
slide_path = tmp_path / "slide_1.png"
|
|
slide_path.write_bytes(b"png")
|
|
google_url = (
|
|
"https://fonts.googleapis.com/css2"
|
|
"?family=Poppins:wght@100..900&display=swap"
|
|
)
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Open Sans": {"bold"}},
|
|
)
|
|
|
|
async def fake_upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path,
|
|
temp_dir,
|
|
original_filename,
|
|
font_files,
|
|
original_font_names,
|
|
logger,
|
|
session_dir,
|
|
upload_fonts=True,
|
|
google_font_replacements=None,
|
|
):
|
|
del temp_dir, original_filename, font_files, original_font_names
|
|
del logger, session_dir, upload_fonts
|
|
captured["google_font_replacements"] = google_font_replacements
|
|
return (
|
|
{"Open Sans"},
|
|
{},
|
|
google_font_replacements or {},
|
|
[],
|
|
pptx_path,
|
|
[],
|
|
[],
|
|
{},
|
|
[],
|
|
{},
|
|
)
|
|
|
|
async def fake_create_slide_previews(
|
|
modified_pptx_path,
|
|
temp_dir,
|
|
font_paths_for_install,
|
|
font_mapping,
|
|
explicit_font_aliases,
|
|
protected_font_names,
|
|
max_slides,
|
|
logger,
|
|
session_dir,
|
|
font_stylesheet_urls=None,
|
|
):
|
|
del modified_pptx_path, temp_dir, font_paths_for_install, font_mapping
|
|
del explicit_font_aliases, protected_font_names, max_slides, logger
|
|
del session_dir
|
|
captured["font_stylesheet_urls"] = font_stylesheet_urls
|
|
return [str(slide_path)]
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"upload_fonts_and_fix_fonts_in_pptx",
|
|
fake_upload_fonts_and_fix_fonts_in_pptx,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"create_slide_previews",
|
|
fake_create_slide_previews,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_public_urls_for_local_paths",
|
|
lambda paths: list(paths),
|
|
)
|
|
|
|
response = await fonts_and_slides_preview.upload_fonts_and_preview_handler(
|
|
pptx_file=DummyUploadFile("deck.pptx", content=_fake_pptx_bytes(1)),
|
|
font_files=[],
|
|
original_font_names=[],
|
|
google_font_original_names=["Open Sans Bold"],
|
|
google_font_replacement_names=["Poppins"],
|
|
google_font_urls=[google_url],
|
|
upload_presentation=False,
|
|
temp_dir=str(tmp_path),
|
|
)
|
|
|
|
assert captured["google_font_replacements"] == {"Open Sans Bold": "Poppins"}
|
|
assert captured["font_stylesheet_urls"] == [google_url]
|
|
assert response.fonts == {"Poppins": google_url}
|
|
assert response.slide_image_urls == [str(slide_path)]
|
|
|
|
|
|
def test_build_google_fonts_stylesheet_url_sorts_and_deduplicates_weights():
|
|
assert (
|
|
pptx_font_utils.build_google_fonts_stylesheet_url("DM Sans", weights=[700, 400, 700])
|
|
== "https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;700&display=swap"
|
|
)
|
|
|
|
|
|
def test_build_google_fonts_stylesheet_url_supports_italic_variants():
|
|
assert (
|
|
pptx_font_utils.build_google_fonts_stylesheet_url(
|
|
"Montserrat", variants=["regular", "bold", "italic", "bold_italic"]
|
|
)
|
|
== "https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,400;0,700;1,400;1,700&display=swap"
|
|
)
|
|
|
|
|
|
class _FakeGoogleFontsResponse:
|
|
def __init__(self, status, css):
|
|
self.status = status
|
|
self._css = css
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, tb):
|
|
return False
|
|
|
|
async def text(self):
|
|
return self._css
|
|
|
|
|
|
class _FakeGoogleFontsSession:
|
|
def __init__(self, status, css, requested_urls):
|
|
self._status = status
|
|
self._css = css
|
|
self._requested_urls = requested_urls
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, tb):
|
|
return False
|
|
|
|
def get(self, url, timeout=None):
|
|
self._requested_urls.append(url)
|
|
return _FakeGoogleFontsResponse(self._status, self._css)
|
|
|
|
|
|
def test_check_google_font_availability_rejects_compatibility_font_kit(monkeypatch):
|
|
css = """\
|
|
@font-face {
|
|
font-family: 'Calibri';
|
|
src: url(https://fonts.gstatic.com/l/font?kit=J7afnpV-BGlaFfdAhLEY6w) format('woff2');
|
|
}
|
|
"""
|
|
monkeypatch.setattr(
|
|
pptx_font_utils.aiohttp,
|
|
"ClientSession",
|
|
lambda: _FakeGoogleFontsSession(200, css, []),
|
|
)
|
|
|
|
assert asyncio.run(pptx_font_utils.check_google_font_availability("Calibri")) is False
|
|
|
|
|
|
def test_check_google_font_availability_checks_requested_variant_url(monkeypatch):
|
|
requested_urls = []
|
|
css = """\
|
|
@font-face {
|
|
font-family: 'Montserrat';
|
|
src: url(https://fonts.gstatic.com/s/montserrat/v31/font.woff2) format('woff2');
|
|
}
|
|
"""
|
|
monkeypatch.setattr(
|
|
pptx_font_utils.aiohttp,
|
|
"ClientSession",
|
|
lambda: _FakeGoogleFontsSession(200, css, requested_urls),
|
|
)
|
|
|
|
assert (
|
|
asyncio.run(
|
|
pptx_font_utils.check_google_font_availability(
|
|
"Montserrat", variants=["regular", "bold", "italic"]
|
|
)
|
|
)
|
|
is True
|
|
)
|
|
assert requested_urls == [
|
|
"https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,400;0,700;1,400&display=swap"
|
|
]
|
|
|
|
|
|
def test_extract_fonts_from_oxml_ignores_embedded_font_declarations():
|
|
xml = """\
|
|
<p:presentation xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:embeddedFontLst>
|
|
<p:embeddedFont>
|
|
<p:font typeface="Unused Embedded Font"/>
|
|
<p:regular r:id="rId1"/>
|
|
</p:embeddedFont>
|
|
</p:embeddedFontLst>
|
|
</p:presentation>
|
|
"""
|
|
|
|
assert pptx_font_utils.extract_fonts_from_oxml(xml) == []
|
|
|
|
|
|
def test_extract_fonts_from_oxml_prefers_latin_font_over_script_fallbacks():
|
|
xml = """\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:r>
|
|
<a:rPr>
|
|
<a:latin typeface="Montserrat"/>
|
|
<a:ea typeface="Arial"/>
|
|
<a:cs typeface="Arial"/>
|
|
</a:rPr>
|
|
<a:t>Hello</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
"""
|
|
|
|
assert pptx_font_utils.extract_fonts_from_oxml(xml) == ["Montserrat"]
|
|
|
|
|
|
def test_font_info_entries_preserve_original_variant_name():
|
|
original_names = fonts_and_slides_preview._original_names_by_normalized_variant(
|
|
{"Arial Gras": {"bold"}}
|
|
)
|
|
|
|
entries = fonts_and_slides_preview._font_info_entries(
|
|
[("Arial", None)],
|
|
{"Arial": {"bold"}},
|
|
original_names,
|
|
)
|
|
|
|
assert len(entries) == 1
|
|
assert entries[0].name == "Arial Bold"
|
|
assert entries[0].original_name == "Arial Gras"
|
|
assert entries[0].family_name == "Arial"
|
|
assert entries[0].variant == "bold"
|
|
assert entries[0].variants == ["bold"]
|
|
|
|
|
|
def test_font_info_entries_use_explicit_variants_without_family_expansion():
|
|
entries = fonts_and_slides_preview._font_info_entries(
|
|
[("HK Grotesk", None, ["regular"])],
|
|
{"HK Grotesk": {"regular", "bold", "bold_italic"}},
|
|
)
|
|
|
|
assert len(entries) == 1
|
|
assert entries[0].name == "HK Grotesk Regular"
|
|
assert entries[0].variant == "regular"
|
|
assert entries[0].variants == ["regular"]
|
|
|
|
|
|
def test_font_info_entries_do_not_duplicate_explicit_variant_name():
|
|
entries = fonts_and_slides_preview._font_info_entries(
|
|
[("Aileron Bold", None, ["bold"])],
|
|
{"Aileron": {"bold"}},
|
|
{("Aileron", "bold"): "Aileron Bold"},
|
|
)
|
|
|
|
assert len(entries) == 1
|
|
assert entries[0].name == "Aileron Bold"
|
|
assert entries[0].original_name == "Aileron Bold"
|
|
assert entries[0].family_name == "Aileron"
|
|
assert entries[0].variant == "bold"
|
|
assert entries[0].variants == ["bold"]
|
|
|
|
|
|
def test_preview_dimensions_preserve_converter_aspect_ratio():
|
|
assert fonts_and_slides_preview._preview_dimensions_from_document(
|
|
1280.0, 960.0
|
|
) == (1280, 960)
|
|
assert fonts_and_slides_preview._preview_dimensions_from_document(0, 0) == (
|
|
1280,
|
|
720,
|
|
)
|
|
|
|
|
|
def test_build_slide_preview_html_adds_fixed_viewport_css(monkeypatch):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"absolute_fastapi_asset_url",
|
|
lambda path: f"http://backend.test{path}",
|
|
)
|
|
|
|
html = fonts_and_slides_preview._build_slide_preview_html(
|
|
'<div class="slide-content">Slide</div>',
|
|
'@font-face { font-family: "Khand"; src: url("file:///font.ttf"); }',
|
|
font_links='<link href="https://fonts.googleapis.com/css2?family=Khand:wght@400;700&display=swap" rel="stylesheet">',
|
|
width=1024,
|
|
height=768,
|
|
)
|
|
|
|
assert '<base href="http://backend.test/" />' in html
|
|
assert '<script src="https://cdn.tailwindcss.com"></script>' in html
|
|
assert (
|
|
'<script src="https://cdn.jsdelivr.net/npm/chart.js@4/dist/chart.umd.min.js"></script>'
|
|
in html
|
|
)
|
|
assert "width: 1024px;" in html
|
|
assert "height: 768px;" in html
|
|
assert ".slide-content" in html
|
|
assert "position: relative;" in html
|
|
assert "fonts.googleapis.com/css2?family=Khand" in html
|
|
assert 'font-family: "Khand"' in html
|
|
assert '<div class="slide-content">Slide</div>' in html
|
|
|
|
|
|
def test_font_stylesheet_links_for_slide_html_extracts_tailwind_font_classes():
|
|
links = fonts_and_slides_preview._font_stylesheet_links_for_slide_html(
|
|
"<span class=\"font-['Poppins']\"></span>"
|
|
"<span class=\"font-['DM_Sans']\"></span>"
|
|
)
|
|
|
|
assert "family=Poppins:wght@400;700" in links
|
|
assert "family=DM+Sans:wght@400;700" in links
|
|
assert links.count('rel="stylesheet"') == 2
|
|
|
|
|
|
def test_font_stylesheet_links_skip_embedded_and_uploaded_fonts():
|
|
links = fonts_and_slides_preview._font_stylesheet_links_for_slide_html(
|
|
"<span class=\"font-['Poppins']\"></span>"
|
|
"<span class=\"font-['Snell_Roundhand']\"></span>"
|
|
"<span class=\"font-['DM_Sans']\"></span>",
|
|
"@font-face { font-family: 'Poppins'; src: url(data:font/ttf;base64,AA); }"
|
|
'@font-face { font-family: "Snell Roundhand"; src: url(data:font/ttf;base64,AA); }',
|
|
)
|
|
|
|
assert "family=Poppins" not in links
|
|
assert "family=Snell+Roundhand" not in links
|
|
assert "family=DM+Sans:wght@400;700" in links
|
|
assert links.count('rel="stylesheet"') == 1
|
|
|
|
|
|
def test_font_css_family_aliases_match_tailwind_underscore_font_values():
|
|
css = (
|
|
"@font-face { font-family: 'Hagrid_Text_Heavy'; "
|
|
"src: url('/app_data/pptx-to-html/session/fonts/hagrid.otf'); }"
|
|
"@font-face { font-family: 'Aileron'; "
|
|
"src: url('/app_data/pptx-to-html/session/fonts/aileron.otf'); }"
|
|
)
|
|
|
|
aliases = fonts_and_slides_preview._font_css_family_aliases(css)
|
|
|
|
assert 'font-family: "Hagrid Text Heavy"' in aliases
|
|
assert "hagrid.otf" in aliases
|
|
assert "Aileron" not in aliases
|
|
|
|
|
|
def test_font_face_css_for_declared_fonts_uses_actual_font_metadata(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
font_path = tmp_path / "Formula-Bold.otf"
|
|
font_path.write_bytes(b"font")
|
|
font_url = font_path.resolve().as_uri()
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
lambda path: pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Formula",
|
|
full_name="Formula Bold",
|
|
subfamily_name="Regular",
|
|
postscript_name="FormulaCondensed-Bold",
|
|
weight_class=700,
|
|
),
|
|
)
|
|
|
|
css = fonts_and_slides_preview._font_face_css_for_declared_fonts(
|
|
"@font-face { "
|
|
"font-family: 'Formula_Bold'; "
|
|
"font-weight: 400; "
|
|
f"src: url('{font_url}') format('opentype'); "
|
|
"}"
|
|
)
|
|
|
|
assert 'font-family: "Formula_Bold";' in css
|
|
assert 'font-family: "Formula Bold";' in css
|
|
assert 'font-family: "Formula";' in css
|
|
assert "font-weight: 700;" in css
|
|
assert f'url("{font_url}")' in css
|
|
|
|
|
|
def test_tailwind_fallback_css_handles_converted_slide_utility_classes():
|
|
css = fonts_and_slides_preview._tailwind_fallback_css_for_slide_html(
|
|
'<div class="absolute left-[72.0px] top-[109.7px] '
|
|
'w-[440.5px] h-[57.5px] overflow-visible bg-[#F15560]">'
|
|
'<span class="text-[42.7px] text-[#FFFFFF] font-bold '
|
|
"font-['Formula_Bold']\">CAMPAIGN GOALS</span>"
|
|
"</div>"
|
|
)
|
|
|
|
assert '[class~="absolute"]{position:absolute;}' in css
|
|
assert '[class~="left-[72.0px]"]{left:72.0px;}' in css
|
|
assert '[class~="text-[42.7px]"]{font-size:42.7px;}' in css
|
|
assert '[class~="text-[#FFFFFF]"]{color:#FFFFFF;}' in css
|
|
assert '[class~="font-bold"]{font-weight:700;}' in css
|
|
assert (
|
|
'[class~="font-[\'Formula_Bold\']"]{font-family:"Formula_Bold", Arial, sans-serif;}'
|
|
in css
|
|
)
|
|
|
|
|
|
def test_font_face_css_for_local_fonts_includes_family_and_full_names(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
font_path = tmp_path / "Khand-Bold.ttf"
|
|
font_path.write_bytes(b"font")
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
lambda path: pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Khand",
|
|
full_name="Khand Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
),
|
|
)
|
|
|
|
css = fonts_and_slides_preview._font_face_css_for_local_fonts([str(font_path)])
|
|
|
|
assert 'font-family: "Khand";' in css
|
|
assert 'font-family: "Khand Bold";' in css
|
|
assert f'url("{font_path.resolve().as_uri()}")' in css
|
|
assert "font-weight: 700;" in css
|
|
assert "font-style: normal;" in css
|
|
|
|
|
|
def test_localize_preview_asset_urls_rewrites_app_data_http_urls(monkeypatch, tmp_path):
|
|
image_path = tmp_path / "asset.png"
|
|
image_path.write_bytes(b"png")
|
|
|
|
def fake_resolve(path_or_url):
|
|
assert path_or_url == "/app_data/pptx-to-html/session/images/asset.png"
|
|
return str(image_path)
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"resolve_app_path_to_filesystem",
|
|
fake_resolve,
|
|
)
|
|
|
|
html = (
|
|
'<img src="http://127.0.0.1:5001/app_data/pptx-to-html/session/images/asset.png">'
|
|
"<div style=\"background-image: url('/app_data/pptx-to-html/session/images/asset.png')\"></div>"
|
|
)
|
|
|
|
localized = fonts_and_slides_preview._localize_preview_asset_urls(html)
|
|
|
|
assert localized.count("data:image/png;base64,cG5n") == 2
|
|
assert "http://127.0.0.1:5001/app_data" not in localized
|
|
assert "url('data:image/png;base64,cG5n')" in localized
|
|
|
|
|
|
def test_localize_preview_asset_urls_absolutizes_unresolved_app_data_urls(
|
|
monkeypatch,
|
|
):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"resolve_app_path_to_filesystem",
|
|
lambda _path_or_url: None,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"absolute_fastapi_asset_url",
|
|
lambda path: f"http://backend.test{path}",
|
|
)
|
|
|
|
html = (
|
|
"@font-face { font-family: 'Aileron'; "
|
|
"src: url('/app_data/pptx-to-html/session/fonts/aileron.otf'); }"
|
|
)
|
|
|
|
localized = fonts_and_slides_preview._localize_preview_asset_urls(html)
|
|
|
|
assert (
|
|
"url('http://backend.test/app_data/pptx-to-html/session/fonts/aileron.otf')"
|
|
in localized
|
|
)
|
|
|
|
|
|
def test_localize_preview_asset_urls_leaves_external_urls(monkeypatch):
|
|
calls = []
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"resolve_app_path_to_filesystem",
|
|
lambda path_or_url: calls.append(path_or_url) or None,
|
|
)
|
|
|
|
html = '<img src="https://example.com/image.png">'
|
|
|
|
assert fonts_and_slides_preview._localize_preview_asset_urls(html) == html
|
|
assert calls == []
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_create_slide_previews_from_html_uses_converter_dimensions_and_fonts(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
font_path = tmp_path / "Khand-Bold.ttf"
|
|
font_path.write_bytes(b"font")
|
|
rendered_path = tmp_path / "slide.png"
|
|
rendered_path.write_bytes(b"png")
|
|
render_calls = []
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
lambda path: pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Khand",
|
|
full_name="Khand Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
),
|
|
)
|
|
|
|
class FakeExportTaskService:
|
|
async def convert_pptx_to_html(self, pptx_path, get_fonts=False):
|
|
assert pptx_path == "deck.pptx"
|
|
assert get_fonts is True
|
|
return SimpleNamespace(
|
|
slides=['<div class="slide-content">Slide</div>'],
|
|
font_css=".deck-font { color: black; }",
|
|
width=1024.0,
|
|
height=768.0,
|
|
)
|
|
|
|
async def render_htmls_to_images(self, htmls, width, height):
|
|
render_calls.append((htmls, width, height))
|
|
return SimpleNamespace(paths=[str(rendered_path)])
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"EXPORT_TASK_SERVICE",
|
|
FakeExportTaskService(),
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.render_pptx_slides_to_images(
|
|
modified_pptx_path="deck.pptx",
|
|
font_paths_for_install=[str(font_path)],
|
|
max_slides=1,
|
|
logger=DummyLogger(),
|
|
font_stylesheet_urls=[
|
|
"https://fonts.googleapis.com/css2?family=Montserrat:wght@400&display=swap"
|
|
],
|
|
)
|
|
|
|
assert result == [str(rendered_path)]
|
|
assert len(render_calls) == 1
|
|
htmls, width, height = render_calls[0]
|
|
assert width == 1024
|
|
assert height == 768
|
|
assert len(htmls) == 1
|
|
html = htmls[0]
|
|
assert '<script src="https://cdn.tailwindcss.com"></script>' in html
|
|
assert (
|
|
'<script src="https://cdn.jsdelivr.net/npm/chart.js@4/dist/chart.umd.min.js"></script>'
|
|
in html
|
|
)
|
|
assert ".deck-font { color: black; }" in html
|
|
assert 'font-family: "Khand Bold";' in html
|
|
assert "fonts.googleapis.com/css2?family=Montserrat" in html
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_create_slide_previews_from_html_batches_slides_in_one_task(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
output_paths = [tmp_path / "slide-1.png", tmp_path / "slide-2.png"]
|
|
for output_path in output_paths:
|
|
output_path.write_bytes(b"png")
|
|
render_calls = []
|
|
|
|
class FakeExportTaskService:
|
|
async def convert_pptx_to_html(self, pptx_path, get_fonts=False):
|
|
return SimpleNamespace(
|
|
slides=[
|
|
'<div class="slide-content">One</div>',
|
|
'<div class="slide-content">Two</div>',
|
|
],
|
|
font_css="",
|
|
width=320.0,
|
|
height=180.0,
|
|
)
|
|
|
|
async def render_htmls_to_images(self, htmls, width, height):
|
|
render_calls.append((htmls, width, height))
|
|
return SimpleNamespace(paths=[str(path) for path in output_paths])
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"EXPORT_TASK_SERVICE",
|
|
FakeExportTaskService(),
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.render_pptx_slides_to_images(
|
|
modified_pptx_path="deck.pptx",
|
|
font_paths_for_install=[],
|
|
max_slides=None,
|
|
logger=DummyLogger(),
|
|
)
|
|
|
|
assert len(render_calls) == 1
|
|
htmls, width, height = render_calls[0]
|
|
assert width == 320
|
|
assert height == 180
|
|
assert len(htmls) == 2
|
|
assert "One" in htmls[0]
|
|
assert "Two" in htmls[1]
|
|
assert result == [str(path) for path in output_paths]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_render_pptx_slides_to_images_rejects_image_count_mismatch(monkeypatch):
|
|
class FakeExportTaskService:
|
|
async def convert_pptx_to_html(self, pptx_path, get_fonts=False):
|
|
return SimpleNamespace(
|
|
slides=["<div>One</div>", "<div>Two</div>"],
|
|
font_css="",
|
|
width=320.0,
|
|
height=180.0,
|
|
)
|
|
|
|
async def render_htmls_to_images(self, htmls, width, height):
|
|
return SimpleNamespace(paths=["slide-1.png"])
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"EXPORT_TASK_SERVICE",
|
|
FakeExportTaskService(),
|
|
)
|
|
|
|
with pytest.raises(fonts_and_slides_preview.HTTPException) as exc_info:
|
|
await fonts_and_slides_preview.render_pptx_slides_to_images(
|
|
modified_pptx_path="deck.pptx",
|
|
font_paths_for_install=[],
|
|
max_slides=None,
|
|
logger=DummyLogger(),
|
|
)
|
|
|
|
assert exc_info.value.status_code == 500
|
|
assert "expected 2, got 1" in exc_info.value.detail
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_create_slide_previews_uses_html_render_path(monkeypatch, tmp_path):
|
|
html_paths = [str(tmp_path / "slide1.png"), str(tmp_path / "slide2.png")]
|
|
|
|
async def fake_create_from_html(
|
|
modified_pptx_path,
|
|
font_paths_for_install,
|
|
max_slides,
|
|
logger,
|
|
font_stylesheet_urls=None,
|
|
):
|
|
assert modified_pptx_path == "deck.pptx"
|
|
assert font_paths_for_install == ["font.ttf"]
|
|
assert max_slides == 2
|
|
assert font_stylesheet_urls is None
|
|
return html_paths
|
|
|
|
async def fake_persist_files_to_session(pairs):
|
|
return [destination for destination, _source in pairs]
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"render_pptx_slides_to_images",
|
|
fake_create_from_html,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_persist_files_to_session",
|
|
fake_persist_files_to_session,
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.create_slide_previews(
|
|
modified_pptx_path="deck.pptx",
|
|
temp_dir=str(tmp_path),
|
|
font_paths_for_install=["font.ttf"],
|
|
font_mapping={},
|
|
explicit_font_aliases=None,
|
|
protected_font_names=None,
|
|
max_slides=2,
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
)
|
|
|
|
assert result == [
|
|
str(tmp_path / "session" / "slide_1.png"),
|
|
str(tmp_path / "session" / "slide_2.png"),
|
|
]
|
|
|
|
|
|
def test_create_font_alias_config_protects_embedded_font_names(tmp_path):
|
|
alias_path = pptx_font_utils.create_font_alias_config(
|
|
["Akzidenz-Grotesk Heavy", "Open Sauce Bold"],
|
|
temp_dir=str(tmp_path),
|
|
protected_font_names=["Akzidenz-Grotesk Heavy"],
|
|
)
|
|
|
|
alias_xml = open(alias_path, encoding="utf-8").read()
|
|
|
|
assert "<string>Akzidenz-Grotesk</string>" not in alias_xml
|
|
assert "<string>Akzidenz-Grotesk Heavy</string>" not in alias_xml
|
|
assert "<string>Open Sauce Bold</string>" in alias_xml
|
|
assert "<string>Open Sauce</string>" in alias_xml
|
|
|
|
|
|
def test_create_font_alias_config_preserves_explicit_aliases(tmp_path):
|
|
alias_path = pptx_font_utils.create_font_alias_config(
|
|
["Legacy Font Heavy", "Installed Font Heavy"],
|
|
temp_dir=str(tmp_path),
|
|
explicit_aliases={"Legacy Font Heavy": "Installed Font Heavy"},
|
|
)
|
|
|
|
alias_xml = open(alias_path, encoding="utf-8").read()
|
|
|
|
assert "<string>Legacy Font Heavy</string>" in alias_xml
|
|
assert "<string>Installed Font Heavy</string>" in alias_xml
|
|
assert "<string>Legacy Font</string>" not in alias_xml
|
|
|
|
|
|
def test_get_available_and_unavailable_fonts_for_pptx_returns_bold_google_font_url(
|
|
monkeypatch,
|
|
):
|
|
async def fake_to_thread(func, *args, **kwargs):
|
|
return func(*args, **kwargs)
|
|
|
|
monkeypatch.setattr(pptx_font_utils.asyncio, "to_thread", fake_to_thread)
|
|
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda pptx_path, temp_dir: ({"Open Sans"}, [], []),
|
|
)
|
|
|
|
async def fake_check_google_font_availability(font_name: str, variants=None) -> bool:
|
|
assert font_name == "Open Sans"
|
|
assert variants == ["regular"]
|
|
return True
|
|
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"check_google_font_availability",
|
|
fake_check_google_font_availability,
|
|
)
|
|
|
|
available_fonts, unavailable_fonts = asyncio.run(
|
|
pptx_font_utils.get_available_and_unavailable_fonts_for_pptx(
|
|
"presentation.pptx", "/tmp"
|
|
)
|
|
)
|
|
|
|
assert unavailable_fonts == []
|
|
assert available_fonts == [
|
|
(
|
|
"Open Sans",
|
|
"https://fonts.googleapis.com/css2?family=Open+Sans:wght@400&display=swap",
|
|
["regular"],
|
|
)
|
|
]
|
|
|
|
|
|
def test_get_available_and_unavailable_fonts_for_pptx_returns_variant_google_font_url(
|
|
monkeypatch,
|
|
):
|
|
async def fake_to_thread(func, *args, **kwargs):
|
|
return func(*args, **kwargs)
|
|
|
|
monkeypatch.setattr(pptx_font_utils.asyncio, "to_thread", fake_to_thread)
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda pptx_path, temp_dir: ({"Montserrat"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"extract_used_font_variants_from_pptx",
|
|
lambda pptx_path: {"Montserrat": {"regular", "bold", "italic"}},
|
|
)
|
|
|
|
async def fake_check_google_font_availability(font_name: str, variants=None) -> bool:
|
|
assert variants == ["regular", "bold", "italic"]
|
|
return True
|
|
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"check_google_font_availability",
|
|
fake_check_google_font_availability,
|
|
)
|
|
|
|
available_fonts, unavailable_fonts = asyncio.run(
|
|
pptx_font_utils.get_available_and_unavailable_fonts_for_pptx(
|
|
"presentation.pptx", "/tmp"
|
|
)
|
|
)
|
|
|
|
assert unavailable_fonts == []
|
|
assert available_fonts == [
|
|
(
|
|
"Montserrat",
|
|
"https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,400;0,700;1,400&display=swap",
|
|
["regular", "bold", "italic"],
|
|
)
|
|
]
|
|
|
|
|
|
def test_get_available_and_unavailable_fonts_for_pptx_is_variant_aware(
|
|
monkeypatch,
|
|
):
|
|
async def fake_to_thread(func, *args, **kwargs):
|
|
return func(*args, **kwargs)
|
|
|
|
monkeypatch.setattr(pptx_font_utils.asyncio, "to_thread", fake_to_thread)
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda pptx_path, temp_dir: (
|
|
{"HK Grotesk", "HK Grotesk Semi-Bold"},
|
|
[object()],
|
|
[],
|
|
),
|
|
)
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"extract_used_font_variants_from_pptx",
|
|
lambda pptx_path: {
|
|
"HK Grotesk": {"regular"},
|
|
"HK Grotesk Semi-Bold": {"bold"},
|
|
},
|
|
)
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"get_index_of_matching_font_detail_or_none",
|
|
lambda font_name, _details: 0
|
|
if font_name == "HK Grotesk Semi-Bold"
|
|
else None,
|
|
)
|
|
|
|
async def fake_check_google_font_availability(font_name: str, variants=None) -> bool:
|
|
assert font_name == "HK Grotesk"
|
|
assert variants == ["regular"]
|
|
return False
|
|
|
|
monkeypatch.setattr(
|
|
pptx_font_utils,
|
|
"check_google_font_availability",
|
|
fake_check_google_font_availability,
|
|
)
|
|
|
|
available_fonts, unavailable_fonts = asyncio.run(
|
|
pptx_font_utils.get_available_and_unavailable_fonts_for_pptx(
|
|
"presentation.pptx", "/tmp"
|
|
)
|
|
)
|
|
|
|
assert available_fonts == [
|
|
(
|
|
"HK Grotesk Semi-Bold",
|
|
"https://example.com/just-a-placeholder-url.ttf",
|
|
["bold"],
|
|
)
|
|
]
|
|
assert unavailable_fonts == [("HK Grotesk", None, ["regular"])]
|
|
|
|
|
|
def test_extract_used_fonts_from_pptx_only_returns_fonts_used_by_slide_content(tmp_path):
|
|
pptx_path = tmp_path / "font-check.pptx"
|
|
|
|
files = {
|
|
"ppt/presentation.xml": """\
|
|
<p:presentation xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:sldIdLst>
|
|
<p:sldId id="256" r:id="rId1"/>
|
|
</p:sldIdLst>
|
|
<p:embeddedFontLst>
|
|
<p:embeddedFont>
|
|
<p:font typeface="Unused Embedded Font"/>
|
|
<p:regular r:id="rIdEmbedded"/>
|
|
</p:embeddedFont>
|
|
</p:embeddedFontLst>
|
|
</p:presentation>
|
|
""",
|
|
"ppt/_rels/presentation.xml.rels": """\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide"
|
|
Target="slides/slide1.xml"/>
|
|
<Relationship Id="rIdTheme"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
|
|
Target="theme/theme1.xml"/>
|
|
</Relationships>
|
|
""",
|
|
"ppt/theme/theme1.xml": """\
|
|
<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
|
|
<a:themeElements>
|
|
<a:fontScheme name="Custom">
|
|
<a:majorFont>
|
|
<a:latin typeface="Heading Theme Font"/>
|
|
</a:majorFont>
|
|
<a:minorFont>
|
|
<a:latin typeface="Body Theme Font"/>
|
|
</a:minorFont>
|
|
</a:fontScheme>
|
|
</a:themeElements>
|
|
</a:theme>
|
|
""",
|
|
"ppt/slides/slide1.xml": """\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:nvSpPr>
|
|
<p:cNvPr id="2" name="Body Placeholder"/>
|
|
<p:cNvSpPr/>
|
|
<p:nvPr>
|
|
<p:ph type="body" idx="1"/>
|
|
</p:nvPr>
|
|
</p:nvSpPr>
|
|
<p:spPr/>
|
|
<p:txBody>
|
|
<a:bodyPr/>
|
|
<a:lstStyle/>
|
|
<a:p>
|
|
<a:r>
|
|
<a:t>Hello world</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
""",
|
|
"ppt/slides/_rels/slide1.xml.rels": """\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout"
|
|
Target="../slideLayouts/slideLayout1.xml"/>
|
|
</Relationships>
|
|
""",
|
|
"ppt/slideLayouts/slideLayout1.xml": """\
|
|
<p:sldLayout xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:nvSpPr>
|
|
<p:cNvPr id="3" name="Layout Placeholder"/>
|
|
<p:cNvSpPr/>
|
|
<p:nvPr>
|
|
<p:ph type="body" idx="1"/>
|
|
</p:nvPr>
|
|
</p:nvSpPr>
|
|
<p:spPr/>
|
|
<p:txBody>
|
|
<a:bodyPr/>
|
|
<a:lstStyle/>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sldLayout>
|
|
""",
|
|
"ppt/slideLayouts/_rels/slideLayout1.xml.rels": """\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster"
|
|
Target="../slideMasters/slideMaster1.xml"/>
|
|
</Relationships>
|
|
""",
|
|
"ppt/slideMasters/slideMaster1.xml": """\
|
|
<p:sldMaster xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree/>
|
|
</p:cSld>
|
|
<p:txStyles>
|
|
<p:bodyStyle>
|
|
<a:lvl1pPr>
|
|
<a:defRPr>
|
|
<a:latin typeface="+mn-lt"/>
|
|
</a:defRPr>
|
|
</a:lvl1pPr>
|
|
</p:bodyStyle>
|
|
</p:txStyles>
|
|
</p:sldMaster>
|
|
""",
|
|
}
|
|
|
|
with zipfile.ZipFile(pptx_path, "w") as archive:
|
|
for name, content in files.items():
|
|
archive.writestr(name, content)
|
|
|
|
assert pptx_font_utils.extract_used_fonts_from_pptx(str(pptx_path)) == {
|
|
"Body Theme Font"
|
|
}
|
|
|
|
|
|
def test_extract_used_fonts_from_pptx_prefers_latin_font_over_fallbacks(tmp_path):
|
|
pptx_path = tmp_path / "font-fallbacks.pptx"
|
|
|
|
with zipfile.ZipFile(pptx_path, "w") as archive:
|
|
archive.writestr(
|
|
"ppt/presentation.xml",
|
|
"""\
|
|
<p:presentation xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:sldIdLst>
|
|
<p:sldId id="256" r:id="rId1"/>
|
|
</p:sldIdLst>
|
|
</p:presentation>
|
|
""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/_rels/presentation.xml.rels",
|
|
"""\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide"
|
|
Target="slides/slide1.xml"/>
|
|
</Relationships>
|
|
""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/slides/slide1.xml",
|
|
"""\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:r>
|
|
<a:rPr>
|
|
<a:latin typeface="Georgia"/>
|
|
<a:ea typeface="Arial"/>
|
|
<a:cs typeface="Arial"/>
|
|
</a:rPr>
|
|
<a:t>Hello world</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
""",
|
|
)
|
|
|
|
assert pptx_font_utils.extract_used_fonts_from_pptx(str(pptx_path)) == {"Georgia"}
|
|
|
|
|
|
def test_extract_used_font_variants_from_pptx_reads_bold_and_italic_runs(tmp_path):
|
|
pptx_path = tmp_path / "font-variants.pptx"
|
|
|
|
with zipfile.ZipFile(pptx_path, "w") as archive:
|
|
archive.writestr(
|
|
"ppt/presentation.xml",
|
|
"""\
|
|
<p:presentation xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
|
|
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
|
|
<p:sldIdLst>
|
|
<p:sldId id="256" r:id="rId1"/>
|
|
</p:sldIdLst>
|
|
</p:presentation>
|
|
""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/_rels/presentation.xml.rels",
|
|
"""\
|
|
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1"
|
|
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide"
|
|
Target="slides/slide1.xml"/>
|
|
</Relationships>
|
|
""",
|
|
)
|
|
archive.writestr(
|
|
"ppt/slides/slide1.xml",
|
|
"""\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:r>
|
|
<a:rPr b="1">
|
|
<a:latin typeface="Montserrat"/>
|
|
</a:rPr>
|
|
<a:t>Bold</a:t>
|
|
</a:r>
|
|
<a:r>
|
|
<a:rPr i="1">
|
|
<a:latin typeface="Montserrat"/>
|
|
</a:rPr>
|
|
<a:t>Italic</a:t>
|
|
</a:r>
|
|
<a:r>
|
|
<a:rPr b="1" i="1">
|
|
<a:latin typeface="Georgia"/>
|
|
</a:rPr>
|
|
<a:t>Bold italic</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
""",
|
|
)
|
|
|
|
assert pptx_font_utils.extract_used_font_variants_from_pptx(str(pptx_path)) == {
|
|
"Georgia": {"bold_italic"},
|
|
"Montserrat": {"bold", "italic"},
|
|
}
|
|
|
|
|
|
def test_replace_fonts_in_pptx_uses_variant_specific_family_names(tmp_path):
|
|
pptx_path = tmp_path / "font-replace.pptx"
|
|
output_path = tmp_path / "font-replaced.pptx"
|
|
|
|
with zipfile.ZipFile(pptx_path, "w") as archive:
|
|
archive.writestr(
|
|
"ppt/slides/slide1.xml",
|
|
"""\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:pPr>
|
|
<a:defRPr>
|
|
<a:latin typeface="Arial"/>
|
|
</a:defRPr>
|
|
</a:pPr>
|
|
<a:r>
|
|
<a:rPr>
|
|
<a:latin typeface="Arial"/>
|
|
</a:rPr>
|
|
<a:t>Regular</a:t>
|
|
</a:r>
|
|
<a:r>
|
|
<a:rPr b="1">
|
|
<a:latin typeface="Arial"/>
|
|
</a:rPr>
|
|
<a:t>Bold</a:t>
|
|
</a:r>
|
|
<a:r>
|
|
<a:rPr i="1">
|
|
<a:latin typeface="Arial"/>
|
|
</a:rPr>
|
|
<a:t>Italic</a:t>
|
|
</a:r>
|
|
<a:r>
|
|
<a:rPr b="1"/>
|
|
<a:t>Inherited bold</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
""",
|
|
)
|
|
|
|
pptx_font_utils.replace_fonts_in_pptx(
|
|
str(pptx_path),
|
|
{"Arial": "Arial Regular"},
|
|
str(output_path),
|
|
font_variant_mapping={
|
|
"Arial": {
|
|
"regular": "Arial Regular",
|
|
"bold": "Arial Bold",
|
|
"italic": "Arial Italic",
|
|
}
|
|
},
|
|
)
|
|
|
|
with zipfile.ZipFile(output_path, "r") as archive:
|
|
xml = archive.read("ppt/slides/slide1.xml").decode("utf-8")
|
|
|
|
assert 'typeface="Arial Regular"' in xml
|
|
assert 'typeface="Arial Bold"' in xml
|
|
assert 'typeface="Arial Italic"' in xml
|
|
assert xml.count('typeface="Arial Bold"') == 2
|
|
|
|
|
|
def test_replace_fonts_in_pptx_rewrites_xml_without_variant_mapping(tmp_path):
|
|
pptx_path = tmp_path / "font-replace-simple.pptx"
|
|
output_path = tmp_path / "font-replaced-simple.pptx"
|
|
|
|
files = {
|
|
"ppt/slides/slide1.xml": """\
|
|
<p:sld xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:r>
|
|
<a:rPr>
|
|
<a:latin typeface="Akzidenz-Grotesk Heavy"/>
|
|
</a:rPr>
|
|
<a:t>Slide</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sld>
|
|
""",
|
|
"ppt/slideLayouts/slideLayout1.xml": """\
|
|
<p:sldLayout xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main">
|
|
<p:cSld>
|
|
<p:spTree>
|
|
<p:sp>
|
|
<p:txBody>
|
|
<a:p>
|
|
<a:pPr>
|
|
<a:defRPr>
|
|
<a:latin typeface="Akzidenz-Grotesk Heavy"/>
|
|
</a:defRPr>
|
|
</a:pPr>
|
|
</a:p>
|
|
</p:txBody>
|
|
</p:sp>
|
|
</p:spTree>
|
|
</p:cSld>
|
|
</p:sldLayout>
|
|
""",
|
|
"ppt/charts/chart1.xml": """\
|
|
<c:chartSpace xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
|
|
xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart">
|
|
<c:chart>
|
|
<c:title>
|
|
<c:tx>
|
|
<c:rich>
|
|
<a:p>
|
|
<a:r>
|
|
<a:rPr>
|
|
<a:latin typeface="Akzidenz-Grotesk Heavy"/>
|
|
</a:rPr>
|
|
<a:t>Chart</a:t>
|
|
</a:r>
|
|
</a:p>
|
|
</c:rich>
|
|
</c:tx>
|
|
</c:title>
|
|
</c:chart>
|
|
</c:chartSpace>
|
|
""",
|
|
}
|
|
|
|
with zipfile.ZipFile(pptx_path, "w") as archive:
|
|
for name, content in files.items():
|
|
archive.writestr(name, content)
|
|
|
|
pptx_font_utils.replace_fonts_in_pptx(
|
|
str(pptx_path),
|
|
{"Akzidenz-Grotesk Heavy": "Akzidenz-Grotesk Black"},
|
|
str(output_path),
|
|
)
|
|
|
|
with zipfile.ZipFile(output_path, "r") as archive:
|
|
for name in files:
|
|
xml = archive.read(name).decode("utf-8")
|
|
assert 'typeface="Akzidenz-Grotesk Black"' in xml
|
|
assert "Akzidenz-Grotesk Heavy" not in xml
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_uploaded_font_mapping_uses_original_variant_name_and_uploaded_actual_name(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview.asyncio, "to_thread", _run_sync_in_test
|
|
)
|
|
|
|
def fake_get_font_details(path: str) -> pptx_font_utils.FontDetail:
|
|
if path.endswith("Calibri-Bold.ttf"):
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Calibri",
|
|
full_name="Calibri Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
)
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Calibri",
|
|
full_name="Calibri Regular",
|
|
subfamily_name="Regular",
|
|
weight_class=400,
|
|
)
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
fake_get_font_details,
|
|
)
|
|
|
|
(
|
|
custom_font_files,
|
|
font_mapping,
|
|
font_variant_mapping,
|
|
) = await fonts_and_slides_preview._save_uploaded_fonts_to_temp(
|
|
[
|
|
DummyUploadFile("Calibri-Bold.ttf"),
|
|
DummyUploadFile("Calibri-Regular.ttf"),
|
|
],
|
|
["Arial Bold", "Arial Regular"],
|
|
str(tmp_path),
|
|
DummyLogger(),
|
|
)
|
|
|
|
assert [original_name for _, original_name in custom_font_files] == [
|
|
"Arial Bold",
|
|
"Arial Regular",
|
|
]
|
|
assert font_mapping == {
|
|
"Arial Bold": "Calibri Bold",
|
|
"Arial Regular": "Calibri Regular",
|
|
}
|
|
assert font_variant_mapping["Arial"] == {
|
|
"bold": "Calibri Bold",
|
|
"regular": "Calibri Regular",
|
|
}
|
|
assert font_variant_mapping["Arial Bold"] == {"bold": "Calibri Bold"}
|
|
assert font_variant_mapping["Arial Regular"] == {"regular": "Calibri Regular"}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_direct_upload_uses_canonical_name_for_localized_same_family_variant(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview.asyncio, "to_thread", _run_sync_in_test
|
|
)
|
|
|
|
def fake_get_font_details(path: str) -> pptx_font_utils.FontDetail:
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Arial Gras",
|
|
full_name="Arial Gras",
|
|
subfamily_name="Gras",
|
|
weight_class=700,
|
|
)
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
fake_get_font_details,
|
|
)
|
|
|
|
(
|
|
_custom_font_files,
|
|
font_mapping,
|
|
font_variant_mapping,
|
|
) = await fonts_and_slides_preview._save_uploaded_fonts_to_temp(
|
|
[DummyUploadFile("arialbd.ttf")],
|
|
["Arial Bold"],
|
|
str(tmp_path),
|
|
DummyLogger(),
|
|
)
|
|
|
|
assert font_mapping == {"Arial Bold": "Arial Bold"}
|
|
assert font_variant_mapping["Arial"] == {"bold": "Arial Bold"}
|
|
assert font_variant_mapping["Arial Bold"] == {"bold": "Arial Bold"}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_direct_upload_keeps_different_replacement_font_family(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview.asyncio, "to_thread", _run_sync_in_test
|
|
)
|
|
|
|
def fake_get_font_details(path: str) -> pptx_font_utils.FontDetail:
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Khand",
|
|
full_name="Khand Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
)
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
fake_get_font_details,
|
|
)
|
|
|
|
(
|
|
_custom_font_files,
|
|
font_mapping,
|
|
font_variant_mapping,
|
|
) = await fonts_and_slides_preview._save_uploaded_fonts_to_temp(
|
|
[DummyUploadFile("Khand-Bold.ttf")],
|
|
["Arial Bold"],
|
|
str(tmp_path),
|
|
DummyLogger(),
|
|
)
|
|
|
|
assert font_mapping == {"Arial Bold": "Khand Bold"}
|
|
assert font_variant_mapping["Arial"] == {"bold": "Khand Bold"}
|
|
assert font_variant_mapping["Arial Bold"] == {"bold": "Khand Bold"}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_custom_uploads_skip_saved_font_lookup_for_exact_variant_names(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
captured_candidates = []
|
|
captured_replacement = {}
|
|
|
|
def fake_get_font_details(path: str) -> pptx_font_utils.FontDetail:
|
|
if path.endswith("Calibri-Bold.ttf"):
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Calibri",
|
|
full_name="Calibri Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
)
|
|
return pptx_font_utils.FontDetail(
|
|
file=path,
|
|
size_bytes=123,
|
|
family_name="Calibri",
|
|
full_name="Calibri Regular",
|
|
subfamily_name="Regular",
|
|
weight_class=400,
|
|
)
|
|
|
|
async def fake_get_font_uploads_for_names_by_variant(font_names):
|
|
captured_candidates.extend(font_names)
|
|
return {}
|
|
|
|
def fake_replace_fonts_in_pptx(
|
|
_pptx_path,
|
|
font_mapping,
|
|
_output_path,
|
|
font_variant_mapping=None,
|
|
):
|
|
captured_replacement["font_mapping"] = font_mapping
|
|
captured_replacement["font_variant_mapping"] = font_variant_mapping
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda *_args: ({"Arial Bold", "Arial Regular"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Arial": {"regular", "bold"}},
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_details",
|
|
fake_get_font_details,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_uploads_for_names_by_variant",
|
|
fake_get_font_uploads_for_names_by_variant,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"replace_fonts_in_pptx",
|
|
fake_replace_fonts_in_pptx,
|
|
)
|
|
|
|
await fonts_and_slides_preview.upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path="deck.pptx",
|
|
temp_dir=str(tmp_path),
|
|
original_filename="deck.pptx",
|
|
font_files=[
|
|
DummyUploadFile("Calibri-Bold.ttf"),
|
|
DummyUploadFile("Calibri-Regular.ttf"),
|
|
],
|
|
original_font_names=["Arial Bold", "Arial Regular"],
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
upload_fonts=False,
|
|
)
|
|
|
|
assert captured_candidates == []
|
|
assert captured_replacement["font_mapping"] == {
|
|
"Arial Bold": "Calibri Bold",
|
|
"Arial Regular": "Calibri Regular",
|
|
}
|
|
assert captured_replacement["font_variant_mapping"]["Arial"] == {
|
|
"bold": "Calibri Bold",
|
|
"regular": "Calibri Regular",
|
|
}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_saved_font_uploads_are_used_for_missing_preview_fonts(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
saved_regular = FontUpload(
|
|
filename="Arial-Regular.ttf",
|
|
path=str(tmp_path / "Arial-Regular.ttf"),
|
|
normalized_family_name="Arial",
|
|
family_name="Arial",
|
|
full_name="Arial Regular",
|
|
subfamily_name="Regular",
|
|
weight_class=400,
|
|
size_bytes=123,
|
|
)
|
|
saved_bold = FontUpload(
|
|
filename="Arial-Bold.ttf",
|
|
path=str(tmp_path / "Arial-Bold.ttf"),
|
|
normalized_family_name="Arial",
|
|
family_name="Arial",
|
|
full_name="Arial Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
size_bytes=123,
|
|
)
|
|
regular_path = tmp_path / "downloaded-regular.ttf"
|
|
bold_path = tmp_path / "downloaded-bold.ttf"
|
|
regular_path.write_bytes(b"regular")
|
|
bold_path.write_bytes(b"bold")
|
|
captured_replacement = {}
|
|
captured_candidates = []
|
|
|
|
async def fake_get_font_uploads_for_names_by_variant(font_names):
|
|
captured_candidates.extend(font_names)
|
|
return {"Arial": {"regular": saved_regular, "bold": saved_bold}}
|
|
|
|
async def fake_download_font_uploads(font_uploads, _temp_dir):
|
|
assert {font.filename for font in font_uploads} == {
|
|
"Arial-Regular.ttf",
|
|
"Arial-Bold.ttf",
|
|
}
|
|
return {
|
|
saved_regular.id: str(regular_path),
|
|
saved_bold.id: str(bold_path),
|
|
}
|
|
|
|
async def fake_get_font_upload_url(font_upload):
|
|
return f"/app_data/fonts/{font_upload.filename}"
|
|
|
|
def fake_replace_fonts_in_pptx(
|
|
_pptx_path,
|
|
font_mapping,
|
|
_output_path,
|
|
font_variant_mapping=None,
|
|
):
|
|
captured_replacement["font_mapping"] = font_mapping
|
|
captured_replacement["font_variant_mapping"] = font_variant_mapping
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda *_args: ({"Arial"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Arial": {"regular", "bold"}},
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_uploads_for_names_by_variant",
|
|
fake_get_font_uploads_for_names_by_variant,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"download_font_uploads",
|
|
fake_download_font_uploads,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_upload_url",
|
|
fake_get_font_upload_url,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"replace_fonts_in_pptx",
|
|
fake_replace_fonts_in_pptx,
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path="deck.pptx",
|
|
temp_dir=str(tmp_path),
|
|
original_filename="deck.pptx",
|
|
font_files=None,
|
|
original_font_names=None,
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
upload_fonts=True,
|
|
)
|
|
|
|
assert captured_candidates == ["Arial"]
|
|
assert captured_replacement["font_mapping"] == {"Arial": "Arial Regular"}
|
|
assert captured_replacement["font_variant_mapping"]["Arial"] == {
|
|
"regular": "Arial Regular",
|
|
"bold": "Arial Bold",
|
|
}
|
|
assert str(regular_path) in result[5]
|
|
assert str(bold_path) in result[5]
|
|
assert result[1] == {
|
|
"Arial Regular": "/app_data/fonts/Arial-Regular.ttf",
|
|
"Arial Bold": "/app_data/fonts/Arial-Bold.ttf",
|
|
}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_saved_font_upload_for_explicit_variant_uses_normalized_family_name(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
saved_bold = FontUpload(
|
|
filename="Arial-Bold.ttf",
|
|
path=str(tmp_path / "Arial-Bold.ttf"),
|
|
normalized_family_name="Arial",
|
|
family_name="Arial",
|
|
full_name="Arial Bold",
|
|
subfamily_name="Bold",
|
|
weight_class=700,
|
|
size_bytes=123,
|
|
)
|
|
bold_path = tmp_path / "downloaded-bold.ttf"
|
|
bold_path.write_bytes(b"bold")
|
|
captured_replacement = {}
|
|
|
|
async def fake_get_font_uploads_for_names_by_variant(font_names):
|
|
assert font_names == ["Arial Bold"]
|
|
return {"Arial Bold": {"bold": saved_bold}}
|
|
|
|
async def fake_download_font_uploads(_font_uploads, _temp_dir):
|
|
return {saved_bold.id: str(bold_path)}
|
|
|
|
async def fake_get_font_upload_url(font_upload):
|
|
return f"/app_data/fonts/{font_upload.filename}"
|
|
|
|
def fake_replace_fonts_in_pptx(
|
|
_pptx_path,
|
|
font_mapping,
|
|
_output_path,
|
|
font_variant_mapping=None,
|
|
):
|
|
captured_replacement["font_mapping"] = font_mapping
|
|
captured_replacement["font_variant_mapping"] = font_variant_mapping
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda *_args: ({"Arial Bold"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Arial": {"bold"}},
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_uploads_for_names_by_variant",
|
|
fake_get_font_uploads_for_names_by_variant,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"download_font_uploads",
|
|
fake_download_font_uploads,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_upload_url",
|
|
fake_get_font_upload_url,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"replace_fonts_in_pptx",
|
|
fake_replace_fonts_in_pptx,
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path="deck.pptx",
|
|
temp_dir=str(tmp_path),
|
|
original_filename="deck.pptx",
|
|
font_files=None,
|
|
original_font_names=None,
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
upload_fonts=True,
|
|
)
|
|
|
|
assert captured_replacement["font_mapping"] == {"Arial Bold": "Arial Bold"}
|
|
assert captured_replacement["font_variant_mapping"]["Arial Bold"] == {
|
|
"bold": "Arial Bold"
|
|
}
|
|
assert captured_replacement["font_variant_mapping"]["Arial"] == {
|
|
"bold": "Arial Bold"
|
|
}
|
|
assert result[1] == {"Arial Bold": "/app_data/fonts/Arial-Bold.ttf"}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_google_font_replacements_are_used_for_pptx_font_mapping(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
captured_replacement = {}
|
|
captured_candidates = []
|
|
|
|
async def fake_get_font_uploads_for_names_by_variant(font_names):
|
|
captured_candidates.extend(font_names)
|
|
return {}
|
|
|
|
def fake_replace_fonts_in_pptx(
|
|
_pptx_path,
|
|
font_mapping,
|
|
_output_path,
|
|
font_variant_mapping=None,
|
|
):
|
|
captured_replacement["font_mapping"] = font_mapping
|
|
captured_replacement["font_variant_mapping"] = font_variant_mapping
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda *_args: ({"Arial"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_font_variants_by_normalized_name",
|
|
lambda *_args: {"Arial": {"bold"}},
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_font_uploads_for_names_by_variant",
|
|
fake_get_font_uploads_for_names_by_variant,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"replace_fonts_in_pptx",
|
|
fake_replace_fonts_in_pptx,
|
|
)
|
|
|
|
await fonts_and_slides_preview.upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path="deck.pptx",
|
|
temp_dir=str(tmp_path),
|
|
original_filename="deck.pptx",
|
|
font_files=None,
|
|
original_font_names=None,
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
upload_fonts=False,
|
|
google_font_replacements={"Arial Bold": "Poppins"},
|
|
)
|
|
|
|
assert captured_candidates == []
|
|
assert captured_replacement["font_mapping"] == {"Arial Bold": "Poppins"}
|
|
assert captured_replacement["font_variant_mapping"]["Arial"] == {
|
|
"bold": "Poppins"
|
|
}
|
|
assert captured_replacement["font_variant_mapping"]["Arial Bold"] == {
|
|
"bold": "Poppins"
|
|
}
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_embedded_fonts_are_installed_without_rewriting_pptx_names(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
pptx_path = tmp_path / "deck.pptx"
|
|
pptx_path.write_bytes(b"pptx")
|
|
captured_replacement = {}
|
|
|
|
async def fake_prepare_embedded_fonts(*_args, **_kwargs):
|
|
return (
|
|
{"Akzidenz-Grotesk Heavy": "https://example.com/akzidenz-black.otf"},
|
|
{"Akzidenz-Grotesk Heavy": str(tmp_path / "akzidenz-black.otf")},
|
|
{"Akzidenz-Grotesk Heavy": "Akzidenz-Grotesk Black"},
|
|
)
|
|
|
|
def fake_replace_fonts_in_pptx(
|
|
_pptx_path,
|
|
font_mapping,
|
|
_output_path,
|
|
font_variant_mapping=None,
|
|
):
|
|
captured_replacement["font_mapping"] = font_mapping
|
|
captured_replacement["font_variant_mapping"] = font_variant_mapping
|
|
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"extract_raw_fonts_and_embedded_details",
|
|
lambda *_args: ({"Akzidenz-Grotesk Heavy"}, [], []),
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"_prepare_embedded_fonts",
|
|
fake_prepare_embedded_fonts,
|
|
)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"replace_fonts_in_pptx",
|
|
fake_replace_fonts_in_pptx,
|
|
)
|
|
|
|
result = await fonts_and_slides_preview.upload_fonts_and_fix_fonts_in_pptx(
|
|
pptx_path=str(pptx_path),
|
|
temp_dir=str(tmp_path),
|
|
original_filename="deck.pptx",
|
|
font_files=None,
|
|
original_font_names=None,
|
|
logger=DummyLogger(),
|
|
session_dir=str(tmp_path / "session"),
|
|
upload_fonts=True,
|
|
)
|
|
|
|
assert "font_mapping" not in captured_replacement
|
|
assert result[1] == {
|
|
"Akzidenz-Grotesk Heavy": "https://example.com/akzidenz-black.otf",
|
|
}
|
|
assert result[2] == {}
|
|
assert result[5] == [str(tmp_path / "akzidenz-black.otf")]
|
|
assert result[4] == str(pptx_path)
|
|
assert result[7] == {}
|
|
assert result[8] == ["Akzidenz-Grotesk Heavy"]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_download_available_google_fonts_skips_when_api_key_missing(
|
|
monkeypatch,
|
|
tmp_path,
|
|
):
|
|
calls = []
|
|
|
|
async def fake_get_google_font_file_urls(*args, **kwargs):
|
|
calls.append((args, kwargs))
|
|
return []
|
|
|
|
monkeypatch.delenv("GOOGLE_FONTS_API_KEY", raising=False)
|
|
monkeypatch.setattr(
|
|
fonts_and_slides_preview,
|
|
"get_google_font_file_urls",
|
|
fake_get_google_font_file_urls,
|
|
)
|
|
|
|
result = await fonts_and_slides_preview._download_available_google_fonts(
|
|
{"Montserrat"},
|
|
str(tmp_path),
|
|
DummyLogger(),
|
|
)
|
|
|
|
assert result == []
|
|
assert calls == []
|