Build Container / build (push) Successful in 6s
Micropub like-of/repost-of with optional comment; likes on /likes, off the home page and feeds; reposts in the stream. Native favourites/boosts on GoToSocial and likes/reposts/quotes on Bluesky when the target is on that network, link posts for other reposts. Fix double slash in outgoing webmention source URLs. ADR-068. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
224 lines
9.6 KiB
Python
224 lines
9.6 KiB
Python
"""
|
|
Likes and reposts (v2.5.0, ADR-068)
|
|
|
|
Fake GoToSocial and Bluesky servers check that likes/reposts of their own
|
|
posts become native favourites/boosts/likes/reposts, and everything else
|
|
falls back (reposts) or is skipped (likes).
|
|
"""
|
|
|
|
import json
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from starpunk import create_app, syndication
|
|
from starpunk.indieauth import create_access_token
|
|
from starpunk.notes import delete_note, get_note
|
|
from starpunk.syndication import BlueskyClient, MastodonClient, get_note_syndications, process_due
|
|
|
|
SITE = "https://blog.example.com"
|
|
GTS = "https://social.example.com"
|
|
FEDI_POST = "https://mastodon.example/@alice/111"
|
|
BSKY_POST = "https://bsky.app/profile/alice.example/post/3abc"
|
|
WEB_PAGE = "https://someblog.example/2026/a-post"
|
|
|
|
|
|
class FakeGTS:
|
|
def __init__(self):
|
|
self.calls = []
|
|
self.statuses = {}
|
|
|
|
def __call__(self, request):
|
|
path = request.url.path
|
|
self.calls.append((request.method, path))
|
|
if path == "/api/v2/search":
|
|
q = request.url.params["q"]
|
|
return httpx.Response(200, json={"statuses": [{"id": "s1"}] if q == FEDI_POST else []})
|
|
if path in ("/api/v1/statuses/s1/favourite", "/api/v1/statuses/s1/unfavourite",
|
|
"/api/v1/statuses/s1/reblog", "/api/v1/statuses/s1/unreblog"):
|
|
return httpx.Response(200, json={"id": "s1"})
|
|
if path == "/api/v1/statuses" and request.method == "POST":
|
|
sid = f"p{len(self.statuses) + 1}"
|
|
self.statuses[sid] = json.loads(request.content)
|
|
return httpx.Response(200, json={"id": sid, "url": f"{GTS}/@phil/statuses/{sid}"})
|
|
if path.startswith("/api/v1/statuses/") and request.method == "DELETE":
|
|
self.statuses.pop(path.rsplit("/", 1)[1], None)
|
|
return httpx.Response(200, json={})
|
|
return httpx.Response(500)
|
|
|
|
|
|
class FakePDS:
|
|
def __init__(self):
|
|
self.records = {}
|
|
self.calls = []
|
|
|
|
def __call__(self, request):
|
|
nsid = request.url.path.removeprefix("/xrpc/")
|
|
self.calls.append(nsid)
|
|
if nsid == "com.atproto.server.createSession":
|
|
return httpx.Response(200, json={"did": "did:plc:me", "handle": "me.example",
|
|
"accessJwt": "a", "refreshJwt": "r"})
|
|
if nsid == "com.atproto.identity.resolveHandle":
|
|
return httpx.Response(200, json={"did": "did:plc:alice"})
|
|
if nsid == "app.bsky.feed.getPosts":
|
|
return httpx.Response(200, json={"posts": [{"uri": request.url.params["uris"], "cid": "cid1"}]})
|
|
if nsid == "com.atproto.repo.createRecord":
|
|
body = json.loads(request.content)
|
|
uri = f"at://did:plc:me/{body['collection']}/r{len(self.records) + 1}"
|
|
self.records[uri] = body["record"]
|
|
return httpx.Response(200, json={"uri": uri, "cid": "c"})
|
|
if nsid == "com.atproto.repo.deleteRecord":
|
|
body = json.loads(request.content)
|
|
self.records.pop(f"at://{body['repo']}/{body['collection']}/{body['rkey']}", None)
|
|
return httpx.Response(200, json={})
|
|
return httpx.Response(500, json={"error": nsid})
|
|
|
|
|
|
@pytest.fixture
|
|
def gts():
|
|
return FakeGTS()
|
|
|
|
|
|
@pytest.fixture
|
|
def pds():
|
|
return FakePDS()
|
|
|
|
|
|
@pytest.fixture
|
|
def app(tmp_path, gts, pds):
|
|
data = tmp_path / "data"
|
|
app = create_app({
|
|
"TESTING": True, "SITE_URL": SITE, "ADMIN_ME": "https://example.com", "SESSION_SECRET": "x",
|
|
"DATA_PATH": data, "NOTES_PATH": data / "notes", "DATABASE_PATH": data / "starpunk.db",
|
|
"GOTOSOCIAL_URL": GTS, "GOTOSOCIAL_ACCESS_TOKEN": "t",
|
|
"BLUESKY_HANDLE": "me.example", "BLUESKY_APP_PASSWORD": "p", "BLUESKY_SERVICE": "https://pds.example",
|
|
"FEED_CACHE_ENABLED": False,
|
|
})
|
|
# The feed's note list is cached at module level across apps
|
|
from starpunk.routes import public
|
|
public._feed_cache["notes"] = None
|
|
public._feed_cache["timestamp"] = None
|
|
syndication._client_cache[GTS] = MastodonClient(GTS, "t", http=httpx.Client(transport=httpx.MockTransport(gts)))
|
|
syndication._client_cache["bluesky:https://pds.example:me.example"] = BlueskyClient(
|
|
"https://pds.example", "me.example", "p", http=httpx.Client(transport=httpx.MockTransport(pds)))
|
|
yield app
|
|
syndication._client_cache.clear()
|
|
|
|
|
|
@pytest.fixture
|
|
def post(app, monkeypatch):
|
|
# Don't fetch contexts from the network
|
|
monkeypatch.setattr("starpunk.reply_context.fetch_reply_context", lambda *a, **k: None)
|
|
with app.test_request_context():
|
|
token = create_access_token("https://quill.example/", "create update delete")["access_token"]
|
|
client = app.test_client()
|
|
|
|
def _post(**props):
|
|
response = client.post("/micropub", json={"type": ["h-entry"], "properties": props},
|
|
headers={"Authorization": f"Bearer {token}"})
|
|
assert response.status_code == 201, response.get_json()
|
|
location = response.headers["Location"]
|
|
with app.app_context():
|
|
note = get_note(slug=location.rsplit("/", 1)[1])
|
|
process_due(limit=10)
|
|
rows = {r["target"]: r for r in get_note_syndications(note.id)}
|
|
return note, rows
|
|
return _post
|
|
|
|
|
|
def page(app, path):
|
|
return app.test_client().get(path).data.decode()
|
|
|
|
|
|
class TestSite:
|
|
def test_like_without_comment(self, app, post):
|
|
note, _ = post(**{"like-of": [WEB_PAGE]})
|
|
assert note.kind == "like" and note.content == ""
|
|
assert note.slug not in page(app, "/")
|
|
likes = page(app, "/likes")
|
|
assert f'class="u-like-of" href="{WEB_PAGE}"' in likes and "★ Liked" in likes
|
|
assert note.slug not in page(app, "/feed.json")
|
|
|
|
def test_repost_in_stream_and_feed(self, app, post):
|
|
note, _ = post(**{"repost-of": [WEB_PAGE], "content": ["Worth a read"]})
|
|
home = page(app, "/")
|
|
assert f'class="u-repost-of" href="{WEB_PAGE}"' in home and "Worth a read" in home
|
|
feed = json.loads(page(app, "/feed.json"))
|
|
item = next(i for i in feed["items"] if note.slug in i["url"])
|
|
assert "Reposted" in item["content_html"] and WEB_PAGE in item["content_html"]
|
|
|
|
def test_webmention_goes_to_target_with_clean_url(self, app, post, monkeypatch):
|
|
sent = {}
|
|
monkeypatch.setattr("starpunk.webmention_sender.queue_webmentions_for_note",
|
|
lambda **kw: sent.update(kw) or 0)
|
|
app.config["WEBMENTION_ENABLED"] = True
|
|
note, _ = post(**{"like-of": [WEB_PAGE]})
|
|
assert sent["in_reply_to"] == WEB_PAGE
|
|
assert sent["note_url"] == f"{SITE}/note/{note.slug}" # no double slash
|
|
|
|
def test_both_kinds_rejected(self, app, post):
|
|
with pytest.raises(AssertionError):
|
|
post(**{"like-of": [WEB_PAGE], "repost-of": [WEB_PAGE]})
|
|
|
|
|
|
class TestGoToSocial:
|
|
def test_like_of_fediverse_post_favourites(self, app, post, gts):
|
|
note, rows = post(**{"like-of": [FEDI_POST]})
|
|
assert rows["gotosocial"]["remote_id"] == "favourite:s1"
|
|
assert rows["gotosocial"]["remote_url"] is None
|
|
with app.test_request_context():
|
|
delete_note(id=note.id)
|
|
process_due(limit=10)
|
|
assert ("POST", "/api/v1/statuses/s1/unfavourite") in gts.calls
|
|
|
|
def test_like_of_web_page_is_not_crossposted(self, app, post, gts):
|
|
_, rows = post(**{"like-of": [WEB_PAGE]})
|
|
assert rows["gotosocial"]["state"] == "synced" and rows["gotosocial"]["remote_id"] is None
|
|
assert gts.statuses == {}
|
|
|
|
def test_repost_boosts(self, app, post, gts):
|
|
_, rows = post(**{"repost-of": [FEDI_POST]})
|
|
assert rows["gotosocial"]["remote_id"] == "reblog:s1"
|
|
|
|
def test_repost_with_comment_posts_status(self, app, post, gts):
|
|
_, rows = post(**{"repost-of": [FEDI_POST], "content": ["So true"]})
|
|
(status,) = gts.statuses.values()
|
|
assert status["status"].startswith("So true") and FEDI_POST in status["status"]
|
|
assert ("POST", "/api/v1/statuses/s1/reblog") not in gts.calls
|
|
|
|
def test_repost_of_web_page_posts_link(self, app, post, gts):
|
|
post(**{"repost-of": [WEB_PAGE]})
|
|
(status,) = gts.statuses.values()
|
|
assert status["status"].startswith("🔁") and WEB_PAGE in status["status"]
|
|
|
|
|
|
class TestBluesky:
|
|
def test_like_of_bluesky_post(self, app, post, pds):
|
|
note, rows = post(**{"like-of": [BSKY_POST]})
|
|
uri = rows["bluesky"]["remote_id"]
|
|
assert "/app.bsky.feed.like/" in uri
|
|
assert pds.records[uri]["subject"] == {"uri": "at://did:plc:alice/app.bsky.feed.post/3abc", "cid": "cid1"}
|
|
with app.test_request_context():
|
|
delete_note(id=note.id)
|
|
process_due(limit=10)
|
|
assert uri not in pds.records
|
|
|
|
def test_like_of_web_page_skipped(self, app, post, pds):
|
|
_, rows = post(**{"like-of": [WEB_PAGE]})
|
|
assert rows["bluesky"]["remote_id"] is None and pds.records == {}
|
|
|
|
def test_repost_and_quote(self, app, post, pds):
|
|
_, rows = post(**{"repost-of": [BSKY_POST]})
|
|
assert "/app.bsky.feed.repost/" in rows["bluesky"]["remote_id"]
|
|
_, rows = post(**{"repost-of": [BSKY_POST], "content": ["Great thread"]})
|
|
record = pds.records[rows["bluesky"]["remote_id"]]
|
|
assert record["text"] == "Great thread"
|
|
assert record["embed"] == {"$type": "app.bsky.embed.record",
|
|
"record": {"uri": "at://did:plc:alice/app.bsky.feed.post/3abc", "cid": "cid1"}}
|
|
|
|
def test_repost_of_web_page_posts_link_card(self, app, post, pds):
|
|
_, rows = post(**{"repost-of": [WEB_PAGE]})
|
|
record = pds.records[rows["bluesky"]["remote_id"]]
|
|
assert record["embed"]["external"]["uri"] == WEB_PAGE
|
|
assert record["text"].startswith("🔁")
|