Files
StarPunk/tests/test_micropub_v290.py
T
PhilandClaude Opus 5.5 ab6ff60f5c feat: Micropub review fixes (v2.9.0)
- mp-syndicate-to/mp-slug read from JSON properties; absent means no
  crossposting
- Sanitize rendered HTML (nh3 allowlist)
- q=source/q=category need a posting scope; draft scope creates drafts;
  private/unlisted visibility saved as drafts
- Photos that can't be fetched or found fail the request; remote photos
  via the SSRF-checked, pinned fetcher
- JSON scalars wrapped, update delete values must be arrays
- bookmark-of stored; HTML content returned as {html} (migration 015)
- published stored as UTC, bad dates 400; malformed JSON 400
- Auth: case-insensitive Bearer, header+body 400, WWW-Authenticate

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:11:23 -07:00

250 lines
11 KiB
Python

"""
Micropub compliance fixes (v2.9.0)
Section numbers refer to the W3C Micropub Recommendation.
"""
import io
import sqlite3
import httpx
import pytest
from tests.test_micropub_v240 import SITE, app, auth, client, create, h, jpeg, note_at, source # noqa: F401
def syndications(app, url):
note = note_at(app, url)
db = sqlite3.connect(app.config["DATABASE_PATH"])
return sorted(r[0] for r in db.execute("SELECT target FROM syndications WHERE note_id = ?", (note.id,)))
@pytest.fixture
def targets(app):
app.config.update(BLUESKY_HANDLE="me.example", BLUESKY_APP_PASSWORD="p")
from starpunk import syndication
syndication._client_cache.clear()
with app.app_context():
return {t.uid: name for name, t in syndication.get_targets().items()}
# Crossposting: mp-* in JSON properties; absent means none
def test_mp_syndicate_to_inside_json_properties(app, client, h, targets):
bsky_uid = next(uid for uid, name in targets.items() if name == "bluesky")
url = create(client, h, **{"mp-syndicate-to": [bsky_uid]})
assert syndications(app, url) == ["bluesky"]
@pytest.mark.parametrize("extra", [{}, {"mp-syndicate-to": []}])
def test_no_choice_means_no_crossposting(app, client, h, targets, extra):
url = create(client, h, **extra)
assert syndications(app, url) == []
def test_form_mp_syndicate_to(app, client, h, targets):
bsky_uid = next(uid for uid, name in targets.items() if name == "bluesky")
response = client.post("/micropub", data={"content": "x", "mp-syndicate-to[]": bsky_uid}, headers=h)
assert syndications(app, response.headers["Location"]) == ["bluesky"]
def test_mp_slug_inside_json_properties(app, client, h):
url = create(client, h, **{"mp-slug": ["my-slug"]})
assert url.endswith("/note/my-slug")
assert "mp-slug" not in source(client, h, url)["properties"]
# Scopes
def test_source_needs_a_posting_scope(app, client, h):
create(client, h, **{"post-status": ["draft"]})
profile_only = auth(app, "profile")
assert client.get("/micropub?q=source", headers=profile_only).status_code == 403
assert client.get("/micropub?q=category", headers=profile_only).status_code == 403
assert client.get("/micropub?q=config", headers=profile_only).status_code == 200
def test_draft_scope_only_creates_drafts(app, client):
url = create(client, auth(app, "draft"))
assert note_at(app, url).published is False
# Visibility
@pytest.mark.parametrize("visibility,published", [("public", True), ("unlisted", False), ("private", False)])
def test_visibility(app, client, h, visibility, published):
url = create(client, h, visibility=[visibility])
assert note_at(app, url).published is published
def test_unknown_visibility_rejected(client, h):
body = {"type": ["h-entry"], "properties": {"content": ["x"], "visibility": ["friends"]}}
assert client.post("/micropub", json=body, headers=h).status_code == 400
# Photos that can't be used fail the request
def test_unreachable_photo_is_an_error(app, client, h, monkeypatch):
monkeypatch.setattr("starpunk.webmention_ssrf.TRANSPORT", httpx.MockTransport(lambda r: httpx.Response(404)))
monkeypatch.setattr("starpunk.webmention_ssrf.socket.getaddrinfo",
lambda *a, **k: [(2, 1, 6, "", ("93.184.216.34", 0))])
body = {"type": ["h-entry"], "properties": {"content": ["x"], "photo": ["https://p.example/404.jpg"]}}
assert client.post("/micropub", json=body, headers=h).status_code == 400
assert client.get("/micropub?q=source", headers=h).get_json()["items"] == []
def test_unknown_local_media_is_an_error_on_update(app, client, h):
url = create(client, h)
response = client.post("/micropub", json={"action": "update", "url": url,
"replace": {"photo": [f"{SITE}/media/2026/11/nope.jpg"]}}, headers=h)
assert response.status_code == 400
def test_redirect_to_private_address_is_not_fetched(app, client, h, monkeypatch):
def resolve(host, *a, **k):
return [(2, 1, 6, "", ("10.0.0.5" if host == "internal.example" else "93.184.216.34", 0))]
def site(request):
return httpx.Response(302, headers={"Location": "http://internal.example/secret.jpg"})
monkeypatch.setattr("starpunk.webmention_ssrf.socket.getaddrinfo", resolve)
monkeypatch.setattr("starpunk.webmention_ssrf.TRANSPORT", httpx.MockTransport(site))
body = {"type": ["h-entry"], "properties": {"content": ["x"], "photo": ["https://p.example/a.jpg"]}}
assert client.post("/micropub", json=body, headers=h).status_code == 400
# JSON values must be arrays (3.3.2)
def test_scalar_json_values_are_not_split(app, client, h):
body = {"type": ["h-entry"], "properties": {"content": "whole text", "category": "solo", "name": "Title"}}
response = client.post("/micropub", json=body, headers=h)
props = source(client, h, response.headers["Location"])["properties"]
assert props["content"] == ["whole text"]
assert props["category"] == ["solo"]
assert props["name"] == ["Title"]
def test_update_delete_values_must_be_arrays(app, client, h):
url = create(client, h, category=["a", "b"])
response = client.post("/micropub", json={"action": "update", "url": url, "delete": {"category": "a"}}, headers=h)
assert response.status_code == 400
def test_update_needs_an_operation(app, client, h):
url = create(client, h)
assert client.post("/micropub", json={"action": "update", "url": url}, headers=h).status_code == 400
def test_person_tag_categories_are_ignored(app, client, h):
url = create(client, h, category=["kept", {"type": ["h-card"], "properties": {"url": ["https://a.example/"]}}])
assert source(client, h, url)["properties"]["category"] == ["kept"]
# Properties that used to be dropped
def test_bookmark_of(app, client, h):
body = {"type": ["h-entry"], "properties": {"bookmark-of": ["https://read.example/post"]}}
url = client.post("/micropub", json=body, headers=h).headers["Location"]
note = note_at(app, url)
assert note.kind == "bookmark" and note.bookmark_of == "https://read.example/post"
props = source(client, h, url)["properties"]
assert props["bookmark-of"] == ["https://read.example/post"] and "content" not in props
page = client.get(url.replace(SITE, "")).data.decode()
assert 'class="u-bookmark-of" href="https://read.example/post"' in page
def test_summary_or_name_without_content(app, client, h):
response = client.post("/micropub", json={"type": ["h-entry"], "properties": {"summary": ["Just a summary"]}},
headers=h)
assert source(client, h, response.headers["Location"])["properties"]["content"] == ["Just a summary"]
response = client.post("/micropub", json={"type": ["h-entry"], "properties": {"name": ["Only a title"]}},
headers=h)
assert source(client, h, response.headers["Location"])["properties"]["name"] == ["Only a title"]
@pytest.mark.parametrize("prop", ["video", "audio"])
def test_unsupported_media_is_refused(client, h, prop):
body = {"type": ["h-entry"], "properties": {"content": ["x"], prop: ["https://m.example/clip"]}}
assert client.post("/micropub", json=body, headers=h).status_code == 400
upload = {"content": "x", prop: (io.BytesIO(b"data"), "clip.mp4")}
assert client.post("/micropub", data=upload, headers=h, content_type="multipart/form-data").status_code == 400
# HTML content (3.7.2) and sanitizing
def test_html_content_comes_back_as_html(app, client, h):
url = create(client, h, content=[{"html": "<p>Some <b>bold</b> text</p>"}])
assert source(client, h, url)["properties"]["content"] == [{"html": "<p>Some <b>bold</b> text</p>"}]
url = create(client, h, content=["plain *markdown*"])
assert source(client, h, url)["properties"]["content"] == ["plain *markdown*"]
def test_update_with_html_content(app, client, h):
url = create(client, h)
client.post("/micropub", json={"action": "update", "url": url,
"replace": {"content": [{"html": "<p>new</p>"}]}}, headers=h)
assert source(client, h, url)["properties"]["content"] == [{"html": "<p>new</p>"}]
def test_html_is_sanitized_on_the_page(app, client, h):
url = create(client, h, content=[{"html": '<p>hi<script>alert(1)</script><img src="/x.jpg" onerror="evil()">'
'<a href="javascript:alert(2)">j</a><iframe src="https://e.example"></iframe></p>'}])
page = client.get(url.replace(SITE, "")).data.decode()
for bad in ("<script>alert(1)", "onerror", "javascript:alert", "<iframe"):
assert bad not in page
assert '<img src="/x.jpg">' in page
# published (3.3)
def test_published_is_stored_as_utc(app, client, h):
url = create(client, h, published=["2020-02-03T04:05:06-08:00"])
assert source(client, h, url)["properties"]["published"] == ["2020-02-03T12:05:06Z"]
created = note_at(app, url).created_at
assert created.tzinfo is None and (created.hour, created.minute) == (12, 5)
def test_unparseable_published_is_an_error(client, h):
body = {"type": ["h-entry"], "properties": {"content": ["x"], "published": ["yesterday"]}}
assert client.post("/micropub", json=body, headers=h).status_code == 400
# Errors (3.8) and authentication (5)
@pytest.mark.parametrize("payload", ["{not json", "[1, 2]"])
def test_malformed_json_is_400(client, h, payload):
response = client.post("/micropub", data=payload, headers={**h, "Content-Type": "application/json"})
assert response.status_code == 400
assert response.get_json()["error"] == "invalid_request"
def test_bearer_scheme_is_case_insensitive(client, h):
lower = {"Authorization": h["Authorization"].replace("Bearer", "bearer")}
assert client.get("/micropub?q=config", headers=lower).status_code == 200
def test_token_in_header_and_body_is_400(client, h):
response = client.post("/micropub", data={"content": "x", "access_token": "other"}, headers=h)
assert response.status_code == 400
def test_401_has_www_authenticate(client):
response = client.get("/micropub?q=config")
assert response.status_code == 401
assert response.headers["WWW-Authenticate"].startswith("Bearer")
response = client.get("/micropub?q=config", headers={"Authorization": "Bearer nope"})
assert 'error="invalid_token"' in response.headers["WWW-Authenticate"]
def test_media_error_does_not_leak_internals(client, h):
response = client.post("/micropub/media", data={"file": (io.BytesIO(b"not an image"), "a.jpg")},
headers=h, content_type="multipart/form-data")
assert response.status_code == 400
assert "BytesIO" not in response.get_json()["error_description"]
def test_config_lists_bookmarks(client, h):
types = {t["type"] for t in client.get("/micropub?q=config", headers=h).get_json()["post-types"]}
assert "bookmark" in types