- Responses as u-comment/u-like/u-repost/u-bookmark/u-mention h-cites with author h-cards; source's own url and published (migration 014) - dt-* and Micropub published in RFC 3339 UTC - Title only for a real Markdown heading (hashtag notes stay notes) - Ignore webmentions from a note's own syndicated copies - Micropub/IndieAuth links independent of Webmention; rel=me/rel=author - Representative h-card and authorship algorithm (starpunk/mf2_utils.py) - Tag/likes h-feeds get url and author; previews get u-uid Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
269 lines
11 KiB
Python
269 lines
11 KiB
Python
"""
|
|
Microformats2 fixes (v2.8.0)
|
|
|
|
Pages are rendered and parsed with mf2py; assertions are on the parsed data,
|
|
which is what IndieWeb readers and Webmention receivers see.
|
|
"""
|
|
|
|
import re
|
|
import sqlite3
|
|
from unittest.mock import patch
|
|
|
|
import mf2py
|
|
import pytest
|
|
|
|
from starpunk import mf2_utils
|
|
from starpunk.models import split_title
|
|
from starpunk.webmention_processor import extract_author, extract_source_details
|
|
from starpunk.webmention_worker import WebmentionWorker
|
|
|
|
BASE = 'http://localhost:5000'
|
|
|
|
|
|
def parse(client, path):
|
|
response = client.get(path)
|
|
assert response.status_code == 200
|
|
return mf2py.parse(doc=response.data.decode(), url=BASE + path)
|
|
|
|
|
|
def entry_of(parsed):
|
|
return next(i for i in parsed['items'] if 'h-entry' in i['type'])
|
|
|
|
|
|
def make_note(app, content, **kw):
|
|
from starpunk.notes import create_note
|
|
with app.test_request_context():
|
|
return create_note(content, published=True, **kw)
|
|
|
|
|
|
def add_mention(app, note, kind, n, photo=True, **cols):
|
|
db = sqlite3.connect(app.config['DATABASE_PATH'])
|
|
fields = {
|
|
'source_url': f'https://src.example/{kind}/{n}',
|
|
'target_url': f'{BASE}/note/{note.slug}',
|
|
'target_note_id': note.id,
|
|
'mention_type': kind,
|
|
'author_name': f'{kind.title()} Person {n}',
|
|
'author_url': f'https://{kind}{n}.example/',
|
|
'author_photo': f'https://{kind}{n}.example/me.jpg' if photo else None,
|
|
'content_snippet': f'<p>{kind} text <a href="https://x.example/">link</a></p>',
|
|
'validation_status': 'valid',
|
|
'moderation_status': 'approved',
|
|
**cols,
|
|
}
|
|
db.execute(f"INSERT INTO webmentions ({', '.join(fields)}) VALUES ({', '.join('?' * len(fields))})",
|
|
tuple(fields.values()))
|
|
db.commit()
|
|
db.close()
|
|
|
|
|
|
# A1/A2: received responses are properties of the entry
|
|
|
|
def test_responses_are_entry_properties(app, client):
|
|
note = make_note(app, "A note")
|
|
add_mention(app, note, 'reply', 1, source_post_url='https://src.example/reply/1#canonical',
|
|
source_published='2026-11-01T10:00:00Z')
|
|
for n in range(10):
|
|
add_mention(app, note, 'like', n, photo=n % 2 == 0)
|
|
add_mention(app, note, 'repost', 1)
|
|
add_mention(app, note, 'bookmark', 1)
|
|
add_mention(app, note, 'mention', 1)
|
|
|
|
props = entry_of(parse(client, f'/note/{note.slug}'))['properties']
|
|
assert 'children' not in entry_of(parse(client, f'/note/{note.slug}'))
|
|
|
|
(comment,) = props['comment']
|
|
assert comment['type'] == ['h-cite']
|
|
author = comment['properties']['author'][0]
|
|
assert author['type'] == ['h-card']
|
|
assert author['properties']['name'] == ['Reply Person 1']
|
|
assert author['properties']['url'] == ['https://reply1.example/']
|
|
assert author['properties']['photo'][0] in ('https://reply1.example/me.jpg',
|
|
{'value': 'https://reply1.example/me.jpg', 'alt': ''})
|
|
assert '<a href="https://x.example/"' in comment['properties']['content'][0]['html']
|
|
# the source's own URL and published time, not ours
|
|
assert comment['properties']['url'] == ['https://src.example/reply/1#canonical']
|
|
assert comment['properties']['published'] == ['2026-11-01T10:00:00Z']
|
|
|
|
# all ten likes, including the ones past the visible eight
|
|
assert len(props['like']) == 10
|
|
names = {like['properties']['author'][0]['properties']['name'][0] for like in props['like']}
|
|
assert names == {f'Like Person {n}' for n in range(10)}
|
|
assert props['like'][0]['properties']['url'] == ['https://src.example/like/0']
|
|
|
|
assert props['repost'][0]['properties']['author'][0]['properties']['name'] == ['Repost Person 1']
|
|
assert props['bookmark'][0]['type'] == ['h-cite']
|
|
assert props['mention'][0]['properties']['author'][0]['properties']['url'] == ['https://mention1.example/']
|
|
|
|
|
|
# A3: dt-* are RFC 3339 UTC
|
|
|
|
UTC = re.compile(r'^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$')
|
|
|
|
|
|
def test_dates_are_utc(app, client):
|
|
from starpunk.notes import update_note
|
|
note = make_note(app, "Dated")
|
|
with app.test_request_context():
|
|
update_note(id=note.id, content="Dated, edited")
|
|
add_mention(app, note, 'reply', 1)
|
|
|
|
props = entry_of(parse(client, f'/note/{note.slug}'))['properties']
|
|
assert UTC.match(props['published'][0]), props['published']
|
|
assert UTC.match(props['updated'][0]), props['updated']
|
|
assert UTC.match(props['comment'][0]['properties']['published'][0])
|
|
|
|
home = parse(client, '/')['items'][0]['children'][0]['properties']
|
|
assert UTC.match(home['published'][0])
|
|
|
|
|
|
def test_micropub_source_published_is_utc():
|
|
from datetime import datetime, timezone, timedelta
|
|
from starpunk.utils import iso_utc
|
|
assert iso_utc(datetime(2026, 11, 1, 16, 25, 12, 921768)) == '2026-11-01T16:25:12Z'
|
|
assert iso_utc(datetime(2026, 11, 1, 9, 0, tzinfo=timezone(timedelta(hours=-7)))) == '2026-11-01T16:00:00Z'
|
|
assert iso_utc('2026-11-01T16:25:15+0000') == '2026-11-01T16:25:15Z'
|
|
|
|
|
|
# A4: only a real Markdown heading is a title
|
|
|
|
@pytest.mark.parametrize("content,title", [
|
|
("# Title\n\nBody", "Title"),
|
|
("## Sub title ##\n\nBody", "Sub title"),
|
|
("#indieweb is great", None),
|
|
("#\n\nbody text", None),
|
|
("####### seven", None),
|
|
("Plain note", None),
|
|
])
|
|
def test_split_title(content, title):
|
|
assert split_title(content)[0] == title
|
|
|
|
|
|
@pytest.mark.parametrize("content,kind", [
|
|
("#indieweb is great, posting from my phone", "note"),
|
|
("#\n\nbody text", "note"),
|
|
("# A Title\n\nThe body", "article"),
|
|
])
|
|
def test_post_type_of_hash_notes(app, client, content, kind):
|
|
note = make_note(app, content)
|
|
for path in (f'/note/{note.slug}', '/'):
|
|
parsed = parse(client, path)
|
|
entry = entry_of(parsed) if path != '/' else parsed['items'][0]['children'][0]
|
|
props = entry['properties']
|
|
if kind == 'note':
|
|
assert 'name' not in props
|
|
assert props['content'][0]['value'].strip()
|
|
else:
|
|
assert props['name'] == ['A Title']
|
|
|
|
|
|
# A5: the note's own syndicated copy is not a response
|
|
|
|
def test_own_syndicated_copy_rejected(app):
|
|
note = make_note(app, "Crossposted")
|
|
db = sqlite3.connect(app.config['DATABASE_PATH'])
|
|
db.execute("INSERT INTO syndications (note_id, target, remote_url) VALUES (?, 'gotosocial', ?)",
|
|
(note.id, 'https://social.example/@me/statuses/1'))
|
|
db.execute("INSERT INTO webmentions (source_url, target_url, target_note_id) VALUES (?, ?, ?)",
|
|
('https://brid.gy/post/mastodon/@someone/1', f'{BASE}/note/{note.slug}', note.id))
|
|
db.commit()
|
|
|
|
result = {'valid': True, 'mention_type': 'mention', 'author_name': 'Me', 'author_url': 'https://me.example/',
|
|
'author_photo': None, 'content_snippet': 'x',
|
|
'source_post_url': 'https://social.example/@me/statuses/1', 'source_uid': None,
|
|
'source_published': None}
|
|
worker = WebmentionWorker(app, db_path=app.config['DATABASE_PATH'], site_url=BASE)
|
|
with patch("starpunk.webmention_worker.process_webmention", return_value=result):
|
|
worker._validate_webmention(1, 'https://brid.gy/post/mastodon/@someone/1', 'x', note.id)
|
|
|
|
status, error = db.execute("SELECT validation_status, validation_error FROM webmentions").fetchone()
|
|
assert status == 'invalid' and 'own syndicated copy' in error
|
|
|
|
|
|
# B1/B3: discovery links
|
|
|
|
def test_head_links_without_webmention(app, client):
|
|
app.config['WEBMENTION_ENABLED'] = False
|
|
rels = parse(client, '/')['rels']
|
|
assert 'webmention' not in rels
|
|
for rel in ('micropub', 'indieauth-metadata', 'authorization_endpoint', 'token_endpoint'):
|
|
assert rels.get(rel), rel
|
|
|
|
|
|
def test_home_has_representative_hcard(app, client):
|
|
# Fresh install: discovery fails, the fallback profile is used
|
|
parsed = parse(client, '/')
|
|
card = mf2_utils.representative_hcard(parsed, BASE + '/')
|
|
assert card and card['properties']['url'] == [app.config['ADMIN_ME']]
|
|
|
|
|
|
@pytest.mark.parametrize("path", ['/likes', '/tag/python'])
|
|
def test_list_feeds_have_url_and_author(app, client, path):
|
|
make_note(app, "Tagged", tags=["python"])
|
|
feed = parse(client, path)['items'][0]
|
|
assert feed['type'] == ['h-feed']
|
|
assert feed['properties']['url'] == [BASE + path]
|
|
assert feed['properties']['author'][0]['type'] == ['h-card']
|
|
|
|
|
|
# B2: representative h-card
|
|
|
|
def _cards(html, url='https://me.example/'):
|
|
return mf2py.parse(doc=html, url=url)
|
|
|
|
|
|
def test_representative_hcard_rules():
|
|
other = '<div class="h-card"><a class="p-name u-url" href="https://bob.example/">Bob</a></div>'
|
|
# someone else's h-card only: none
|
|
assert mf2_utils.representative_hcard(_cards(other), 'https://me.example/') is None
|
|
# uid + url
|
|
me = '<div class="h-card"><a class="p-name u-url u-uid" href="/">Me</a></div>'
|
|
assert mf2_utils.first(mf2_utils.representative_hcard(_cards(other + me), 'https://me.example/'), 'name') == 'Me'
|
|
# rel=me
|
|
relme = ('<a rel="me" href="https://social.example/@me">x</a>'
|
|
'<div class="h-card"><a class="p-name u-url" href="https://social.example/@me">Me</a></div>')
|
|
assert mf2_utils.first(mf2_utils.representative_hcard(_cards(other + relme), 'https://me.example/'), 'name') == 'Me'
|
|
# only one h-card, url = page
|
|
single = '<div class="h-card"><a class="p-name u-url" href="/">Me</a></div>'
|
|
assert mf2_utils.first(mf2_utils.representative_hcard(_cards(single), 'https://me.example/'), 'name') == 'Me'
|
|
|
|
|
|
# B4: the responding entry and its author
|
|
|
|
FEED_PAGE = '''
|
|
<div class="h-feed">
|
|
<div class="p-author h-card"><a class="p-name u-url" href="https://feed.example/">Feed Owner</a></div>
|
|
<div class="h-entry"><a class="u-url" href="https://feed.example/1">one</a>
|
|
<div class="e-content">unrelated</div></div>
|
|
<div class="h-entry"><a class="u-url" href="https://feed.example/2">two</a>
|
|
<time class="dt-published" datetime="2026-11-01T09:00:00-07:00">x</time>
|
|
<a class="u-in-reply-to" href="https://me.example/note/a">re</a>
|
|
<div class="e-content">my reply</div></div>
|
|
</div>'''
|
|
|
|
|
|
def test_responding_entry_and_feed_author():
|
|
parsed = mf2py.parse(doc=FEED_PAGE, url='https://feed.example/')
|
|
entry = mf2_utils.responding_entry(parsed, 'https://me.example/note/a#frag')
|
|
assert mf2_utils.first(entry, 'url') == 'https://feed.example/2'
|
|
assert mf2_utils.response_type(entry, 'https://me.example/note/a') == 'reply'
|
|
|
|
author = extract_author(parsed, 'https://feed.example/', entry)
|
|
assert author['author_name'] == 'Feed Owner'
|
|
assert author['author_url'] == 'https://feed.example/'
|
|
|
|
details = extract_source_details(entry)
|
|
assert details['source_post_url'] == 'https://feed.example/2'
|
|
assert details['source_published'] == '2026-11-01T16:00:00Z'
|
|
|
|
|
|
def test_author_as_url_or_name():
|
|
url_author = '<div class="h-entry"><a class="u-author" href="https://al.example/">al</a></div>'
|
|
parsed = mf2py.parse(doc=url_author, url='https://s.example/')
|
|
assert extract_author(parsed, 'https://s.example/')['author_url'] == 'https://al.example/'
|
|
|
|
name_author = '<div class="h-entry"><span class="p-author">Al Smith</span></div>'
|
|
parsed = mf2py.parse(doc=name_author, url='https://s.example/')
|
|
author = extract_author(parsed, 'https://s.example/')
|
|
assert author['author_name'] == 'Al Smith' and author['author_url'] == 'https://s.example/'
|