Private
Public Access
Feeds that give no publish date left the row with no time at all and grouped the article under "Undated". The stream's sort order already fell back to fetched_at; the list row, its date-group header, and the open article's header now use the same fallback. The article's own published_at stays empty — nothing is invented in the database, so a later refetch can't see a spurious change. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
506 lines
20 KiB
Python
506 lines
20 KiB
Python
import re
|
|
|
|
import pytest
|
|
from django.contrib.auth import get_user_model
|
|
from django.urls import reverse
|
|
|
|
from apps.articles.models import STARRED_TAG_NAME, Article, ArticleTag, UserArticleState
|
|
from apps.feeds.models import Feed, Subscription
|
|
|
|
User = get_user_model()
|
|
|
|
|
|
@pytest.fixture
|
|
def alice(db):
|
|
return User.objects.create_user("alice", password="pw-alice-123")
|
|
|
|
|
|
@pytest.fixture
|
|
def bob(db):
|
|
return User.objects.create_user("bob", password="pw-bob-123")
|
|
|
|
|
|
@pytest.fixture
|
|
def alices_article(alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml", title="Example")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
return Article.objects.create(feed=feed, guid="guid-1", title="Hello world")
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_requires_login(client):
|
|
response = client.get(reverse("reader:stream"))
|
|
assert response.status_code == 302
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_shows_only_own_subscriptions(client, alice, bob, alices_article):
|
|
client.login(username="bob", password="pw-bob-123")
|
|
response = client.get(reverse("reader:stream"))
|
|
assert alices_article.title not in response.content.decode()
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"))
|
|
assert alices_article.title in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_unread_filter_excludes_read_articles(client, alice, alices_article):
|
|
UserArticleState.objects.create(user=alice, article=alices_article, is_read=True)
|
|
client.login(username="alice", password="pw-alice-123")
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "unread"})
|
|
assert alices_article.title not in response.content.decode()
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "all"})
|
|
assert alices_article.title in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_hidden_articles_are_excluded_from_every_filter(client, alice, alices_article):
|
|
UserArticleState.objects.create(user=alice, article=alices_article, is_hidden=True)
|
|
client.login(username="alice", password="pw-alice-123")
|
|
|
|
for active_filter in ["unread", "all"]:
|
|
response = client.get(reverse("reader:stream"), {"filter": active_filter})
|
|
assert alices_article.title not in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_viewing_article_detail_marks_it_read(client, alice, alices_article):
|
|
client.login(username="alice", password="pw-alice-123")
|
|
assert not UserArticleState.objects.filter(user=alice, article=alices_article).exists()
|
|
|
|
response = client.get(reverse("reader:article_detail", args=[alices_article.pk]))
|
|
assert response.status_code == 200
|
|
|
|
state = UserArticleState.objects.get(user=alice, article=alices_article)
|
|
assert state.is_read is True
|
|
assert state.read_at is not None
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_user_cannot_view_another_users_article(client, alice, bob, alices_article):
|
|
client.login(username="bob", password="pw-bob-123")
|
|
response = client.get(reverse("reader:article_detail", args=[alices_article.pk]))
|
|
assert response.status_code == 404
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_toggle_star_flips_state_and_persists(client, alice, alices_article):
|
|
client.login(username="alice", password="pw-alice-123")
|
|
url = reverse("reader:toggle_star", args=[alices_article.pk])
|
|
|
|
response = client.post(url)
|
|
assert response.status_code == 200
|
|
assert ArticleTag.objects.filter(
|
|
user=alice,
|
|
article=alices_article,
|
|
tag__is_system=True,
|
|
tag__name=STARRED_TAG_NAME,
|
|
).exists()
|
|
|
|
client.post(url)
|
|
assert not ArticleTag.objects.filter(
|
|
user=alice,
|
|
article=alices_article,
|
|
tag__is_system=True,
|
|
tag__name=STARRED_TAG_NAME,
|
|
).exists()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_toggle_read_requires_post(client, alice, alices_article):
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:toggle_read", args=[alices_article.pk]))
|
|
assert response.status_code == 405
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_user_cannot_toggle_state_on_another_users_article(client, alice, bob, alices_article):
|
|
client.login(username="bob", password="pw-bob-123")
|
|
response = client.post(reverse("reader:toggle_star", args=[alices_article.pk]))
|
|
assert response.status_code == 404
|
|
assert not UserArticleState.objects.filter(article=alices_article).exists()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_remembers_last_selected_filter(client, alice, alices_article):
|
|
from apps.articles.models import get_system_tag
|
|
|
|
ArticleTag.objects.create(
|
|
user=alice, article=alices_article, tag=get_system_tag(alice, STARRED_TAG_NAME)
|
|
)
|
|
client.login(username="alice", password="pw-alice-123")
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "starred"})
|
|
assert response.context["active_filter"] == "starred"
|
|
|
|
# No ?filter= this time — e.g. a sidebar feed/tag link, or just "/" —
|
|
# should fall back to "starred" rather than resetting to "unread".
|
|
response = client.get(reverse("reader:stream"))
|
|
assert response.context["active_filter"] == "starred"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_tag_filter_includes_articles_from_a_tagged_feed(client, alice, alices_article):
|
|
from apps.articles.models import SubscriptionTag, Tag
|
|
from apps.feeds.models import Subscription
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
tag = Tag.objects.create(user=alice, name="backend")
|
|
subscription = Subscription.objects.get(user=alice, feed=alices_article.feed)
|
|
SubscriptionTag.objects.create(user=alice, subscription=subscription, tag=tag)
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "all", "tag": tag.pk})
|
|
assert alices_article.title in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_saved_filter_only_shows_saved_articles(client, alice, alices_article):
|
|
client.login(username="alice", password="pw-alice-123")
|
|
client.post(reverse("reader:toggle_saved", args=[alices_article.pk]))
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "saved"})
|
|
assert alices_article.title in response.content.decode()
|
|
|
|
response = client.get(reverse("reader:stream"), {"filter": "starred"})
|
|
assert alices_article.title not in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_sidebar_shows_a_tags_total_unread_count(client, alice):
|
|
from apps.articles.models import SubscriptionTag, Tag
|
|
|
|
feed_a = Feed.objects.create(feed_url="https://a.example.com/feed.xml")
|
|
feed_b = Feed.objects.create(feed_url="https://b.example.com/feed.xml")
|
|
sub_a = Subscription.objects.create(user=alice, feed=feed_a)
|
|
sub_b = Subscription.objects.create(user=alice, feed=feed_b)
|
|
tag = Tag.objects.create(user=alice, name="work")
|
|
SubscriptionTag.objects.create(user=alice, subscription=sub_a, tag=tag)
|
|
SubscriptionTag.objects.create(user=alice, subscription=sub_b, tag=tag)
|
|
for i in range(3):
|
|
Article.objects.create(feed=feed_a, guid=f"a-{i}", title=f"A{i}")
|
|
for i in range(4):
|
|
Article.objects.create(feed=feed_b, guid=f"b-{i}", title=f"B{i}")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"))
|
|
|
|
# The only "7" on the page — the individual feeds show 3 and 4.
|
|
content = response.content.decode()
|
|
assert '<span class="unread-count">7</span>' in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_rows_carry_their_utc_instant_for_client_side_date_grouping(client, alice):
|
|
"""The server still groups date headers in UTC, but ships each row's
|
|
raw UTC instant so date-groups.js can rebuild the headers using the
|
|
viewer's local calendar day instead."""
|
|
from django.utils import timezone
|
|
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
dated = Article.objects.create(
|
|
feed=feed, guid="dated", title="Dated", published_at=timezone.now()
|
|
)
|
|
undated = Article.objects.create(feed=feed, guid="undated", title="No publish date")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"), {"filter": "all"})
|
|
content = response.content.decode()
|
|
|
|
expected_iso = dated.published_at.isoformat()
|
|
assert f'id="article-{dated.pk}"' in content
|
|
assert f'data-published-utc="{expected_iso}"' in content
|
|
|
|
# A feed that gave no publish date falls back to when it was fetched
|
|
# (the same fallback the stream's sort order uses), so the row still
|
|
# carries a time and groups under a real date, not "Undated".
|
|
undated_row = re.search(rf'<li id="article-{undated.pk}".*?</li>', content, flags=re.DOTALL)
|
|
assert undated_row is not None
|
|
row_html = undated_row.group(0)
|
|
assert f'data-published-utc="{undated.fetched_at.isoformat()}"' in row_html
|
|
assert 'class="article-time"' in row_html
|
|
assert "Undated" not in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_check_new_articles_reports_nothing_below_the_given_cursor(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
existing = Article.objects.create(feed=feed, guid="existing", title="Existing")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:check_new"), {"filter": "all", "since": existing.pk})
|
|
|
|
assert response.status_code == 200
|
|
assert response.content.decode().strip() == ""
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_check_new_articles_reports_articles_created_after_the_cursor(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
existing = Article.objects.create(feed=feed, guid="existing", title="Existing")
|
|
Article.objects.create(feed=feed, guid="new-1", title="New one")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:check_new"), {"filter": "all", "since": existing.pk})
|
|
|
|
content = response.content.decode()
|
|
assert "1 new article" in content
|
|
assert "click to show" in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_check_new_articles_respects_the_active_tag_scope(client, alice):
|
|
from apps.articles.models import SubscriptionTag, Tag
|
|
|
|
feed_a = Feed.objects.create(feed_url="https://a.example.com/feed.xml")
|
|
feed_b = Feed.objects.create(feed_url="https://b.example.com/feed.xml")
|
|
sub_a = Subscription.objects.create(user=alice, feed=feed_a)
|
|
Subscription.objects.create(user=alice, feed=feed_b)
|
|
tag = Tag.objects.create(user=alice, name="work")
|
|
SubscriptionTag.objects.create(user=alice, subscription=sub_a, tag=tag)
|
|
|
|
cursor = Article.objects.create(feed=feed_a, guid="cursor", title="Cursor").pk
|
|
# New in feed_b, which isn't tagged "work" — shouldn't count for this scope.
|
|
Article.objects.create(feed=feed_b, guid="untagged-new", title="Untagged new")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(
|
|
reverse("reader:check_new"), {"filter": "all", "tag": tag.pk, "since": cursor}
|
|
)
|
|
|
|
assert response.content.decode().strip() == ""
|
|
|
|
# New in feed_a (tagged "work") — should count.
|
|
Article.objects.create(feed=feed_a, guid="tagged-new", title="Tagged new")
|
|
response = client.get(
|
|
reverse("reader:check_new"), {"filter": "all", "tag": tag.pk, "since": cursor}
|
|
)
|
|
assert "1 new article" in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_exposes_the_latest_article_id_and_scope_for_the_banner(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
article = Article.objects.create(feed=feed, guid="g1", title="Hello")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"), {"filter": "all"})
|
|
content = response.content.decode()
|
|
|
|
assert f"since={article.pk}" in content
|
|
assert "filter=all" in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_sidebar_unread_count_updates_immediately_after_reading_an_article(client, alice):
|
|
"""unread_counts_by_feed caches its result for a short TTL (C3) — the
|
|
reader views that change the current user's own read state must
|
|
invalidate it, or the sidebar would show a stale count until the TTL
|
|
elapses on every one of these very common actions."""
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
article = Article.objects.create(feed=feed, guid="a-1", title="Hello")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
|
|
response = client.get(reverse("reader:stream"))
|
|
assert '<span class="unread-count">1</span>' in response.content.decode()
|
|
|
|
client.get(reverse("reader:article_detail", args=[article.pk]))
|
|
|
|
response = client.get(reverse("reader:stream"))
|
|
assert "unread-count" not in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_sidebar_unread_count_updates_immediately_after_toggle_read(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
article = Article.objects.create(feed=feed, guid="a-1", title="Hello")
|
|
UserArticleState.objects.create(user=alice, article=article, is_read=True)
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"))
|
|
assert "unread-count" not in response.content.decode()
|
|
|
|
client.post(reverse("reader:toggle_read", args=[article.pk]))
|
|
|
|
response = client.get(reverse("reader:stream"))
|
|
assert '<span class="unread-count">1</span>' in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_sidebar_unread_count_updates_immediately_after_mark_all_read(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
Article.objects.create(feed=feed, guid="a-1", title="Hello")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
response = client.get(reverse("reader:stream"))
|
|
assert '<span class="unread-count">1</span>' in response.content.decode()
|
|
|
|
client.post(reverse("reader:mark_all_read"))
|
|
|
|
response = client.get(reverse("reader:stream"))
|
|
assert "unread-count" not in response.content.decode()
|
|
|
|
|
|
def _stream_article_ids(client, query):
|
|
response = client.get(reverse("reader:stream"), query)
|
|
content = response.content.decode()
|
|
ids = [int(m) for m in re.findall(r'<li id="article-(\d+)"', content)]
|
|
return ids, content
|
|
|
|
|
|
def _link_query(content, label):
|
|
match = re.search(rf'<a href="\?([^"]+)">{label}', content)
|
|
if not match:
|
|
return None
|
|
from urllib.parse import parse_qsl
|
|
|
|
return dict(parse_qsl(match.group(1).replace("&", "&")))
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_keyset_pagination_pages_through_tied_timestamps_without_gaps(client, alice):
|
|
"""Keyset pagination (C4) on (sort_at, id): articles sharing an exact
|
|
timestamp must neither repeat nor go missing across page boundaries,
|
|
which offset paging over a non-unique order can't guarantee."""
|
|
from django.utils import timezone
|
|
|
|
from apps.reader.views import PAGE_SIZE
|
|
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
same_moment = timezone.now()
|
|
total = PAGE_SIZE * 2 + 5
|
|
created = [
|
|
Article.objects.create(feed=feed, guid=f"g{i}", title=f"T{i}", published_at=same_moment)
|
|
for i in range(total)
|
|
]
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
seen = []
|
|
query = {"filter": "all"}
|
|
pages = 0
|
|
while query:
|
|
ids, content = _stream_article_ids(client, query)
|
|
assert len(ids) <= PAGE_SIZE
|
|
seen.extend(ids)
|
|
query = _link_query(content, "Older")
|
|
pages += 1
|
|
assert pages < 10
|
|
|
|
assert pages == 3
|
|
assert len(seen) == total
|
|
assert sorted(seen) == sorted(a.pk for a in created)
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_newer_link_returns_to_the_previous_page(client, alice):
|
|
from django.utils import timezone
|
|
|
|
from apps.reader.views import PAGE_SIZE
|
|
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
now = timezone.now()
|
|
for i in range(PAGE_SIZE + 5):
|
|
Article.objects.create(
|
|
feed=feed,
|
|
guid=f"g{i}",
|
|
title=f"T{i}",
|
|
published_at=now - timezone.timedelta(minutes=i),
|
|
)
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
first_ids, first_content = _stream_article_ids(client, {"filter": "all"})
|
|
assert _link_query(first_content, "Newer") is None
|
|
|
|
second_ids, second_content = _stream_article_ids(client, _link_query(first_content, "Older"))
|
|
assert len(second_ids) == 5
|
|
assert _link_query(second_content, "Older") is None
|
|
|
|
back_ids, _ = _stream_article_ids(client, _link_query(second_content, "Newer"))
|
|
assert back_ids == first_ids
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_stream_pagination_links_keep_the_feed_scope(client, alice):
|
|
from apps.reader.views import PAGE_SIZE
|
|
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
for i in range(PAGE_SIZE + 1):
|
|
Article.objects.create(feed=feed, guid=f"g{i}", title=f"T{i}")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
_, content = _stream_article_ids(client, {"filter": "all", "feed": feed.pk})
|
|
|
|
assert _link_query(content, "Older")["feed"] == str(feed.pk)
|
|
|
|
|
|
def test_templates_use_no_inline_event_handlers():
|
|
"""Production's CSP (script-src 'self') blocks inline on*= handlers —
|
|
they work in dev, where no CSP is sent, and silently do nothing in
|
|
production. Behavior belongs in static/js."""
|
|
from pathlib import Path
|
|
|
|
from django.conf import settings
|
|
|
|
pattern = re.compile(r"""<[^>]+\s(on[a-z]+)\s*=""", re.IGNORECASE)
|
|
offenders = []
|
|
for template in Path(settings.BASE_DIR, "templates").rglob("*.html"):
|
|
for match in pattern.finditer(template.read_text()):
|
|
offenders.append(f"{template.name}: {match.group(1)}")
|
|
assert offenders == []
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_detail_back_link_keeps_the_stream_scope(client, alice):
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
article = Article.objects.create(feed=feed, guid="g1", title="Hello")
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
stream = client.get(
|
|
reverse("reader:stream"), {"filter": "all", "feed": feed.pk}
|
|
).content.decode()
|
|
link = re.search(r'href="(/articles/\d+/\?[^"]+)"', stream)
|
|
assert link is not None
|
|
|
|
detail = client.get(link.group(1).replace("&", "&")).content.decode()
|
|
assert f"filter=all&feed={feed.pk}" in detail
|
|
assert "Back to stream" in detail
|
|
assert article.title in detail
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_with_no_publish_date_shows_when_it_was_fetched(client, alice):
|
|
"""A feed that gives no date is treated as published when we fetched
|
|
it — in the list row, its group header, and the open article's header
|
|
— without storing an invented value on the article itself."""
|
|
feed = Feed.objects.create(feed_url="https://example.com/feed.xml")
|
|
Subscription.objects.create(user=alice, feed=feed)
|
|
article = Article.objects.create(feed=feed, guid="g1", title="No publish date")
|
|
assert article.published_at is None
|
|
|
|
client.login(username="alice", password="pw-alice-123")
|
|
iso = article.fetched_at.isoformat()
|
|
|
|
stream = client.get(reverse("reader:stream"), {"filter": "all"}).content.decode()
|
|
assert f'datetime="{iso}"' in stream
|
|
assert "Received today" in stream
|
|
|
|
detail = client.get(reverse("reader:article_detail", args=[article.pk])).content.decode()
|
|
assert f'datetime="{iso}"' in detail
|
|
|
|
article.refresh_from_db()
|
|
assert article.published_at is None
|