Files
StarPunk/tests/test_feeds_atom.py
T
PhilandClaude Opus 5.5 978c13358b feat: article titles and summaries stored apart from the text (v2.16.0, ADR-076)
Articles as the IndieWeb defines them: a name separate from the content.

- Migration 023 adds notes.title and notes.summary. A one-time Python data
  step (migrations.DATA_MIGRATIONS) moves each note's '# Heading' first line
  into title, rewrites the file and hash, empties FTS for a rebuild, and puts
  files back if the migration fails. Trashed notes included.
- Micropub: name -> title, summary stored when sent with content, summary
  updatable, q=source returns both. MCP tools take a summary.
- Feeds: titles only for articles (RSS/JSON none, Atom empty); Atom and
  JSON Feed summaries; the title is no longer repeated in the content.
- Pages: p-name/p-summary on the article page. Homepage and tag pages show
  articles as title, summary and "Read more" without images (hidden u-photo
  keeps the post type for parsers).
- Crossposts: articles go out as title, summary, link and hashtags, no
  images; the Bluesky card is the article. Notes unchanged.
- Editor: Title and Summary fields; an article may have no body.
- Fix: a line starting with a hashtag ('#indieweb ...') was rendered as a
  heading and crossposted without its '#' (HashtagLineExtension).
- Fix: excerpts showed raw Markdown; they are plain text now.

Back up the database and the data folder before deploying: the migration
rewrites note files.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 17:05:38 -07:00

307 lines
10 KiB
Python

"""
Tests for ATOM feed generation module
Tests cover:
- ATOM feed generation with various note counts
- RFC 3339 date formatting
- Feed structure and required elements
- Entry ordering (newest first)
- XML escaping
"""
import pytest
from datetime import datetime, timezone
from xml.etree import ElementTree as ET
import time
from starpunk import create_app
from starpunk.feeds.atom import generate_atom, generate_atom_streaming
from starpunk.notes import create_note, list_notes
from tests.helpers.feed_ordering import assert_feed_newest_first
@pytest.fixture
def app(tmp_path):
"""Create test application"""
test_data_dir = tmp_path / "data"
test_data_dir.mkdir(parents=True, exist_ok=True)
test_config = {
"TESTING": True,
"DATABASE_PATH": test_data_dir / "starpunk.db",
"DATA_PATH": test_data_dir,
"NOTES_PATH": test_data_dir / "notes",
"SESSION_SECRET": "test-secret-key",
"ADMIN_ME": "https://test.example.com",
"SITE_URL": "https://example.com",
"SITE_NAME": "Test Blog",
"SITE_DESCRIPTION": "A test blog",
"DEV_MODE": False,
}
app = create_app(config=test_config)
yield app
@pytest.fixture
def sample_notes(app):
"""Create sample published notes"""
with app.app_context():
notes = []
for i in range(5):
note = create_note(
title=f"Test Note {i}", content=f"This is test content for note {i}.",
published=True,
)
notes.append(note)
time.sleep(0.01) # Ensure distinct timestamps
return list_notes(published_only=True, limit=10)
class TestGenerateAtom:
"""Test generate_atom() function"""
def test_generate_atom_basic(self, app, sample_notes):
"""Test basic ATOM feed generation with notes"""
with app.app_context():
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=sample_notes,
)
# Should return XML string
assert isinstance(feed_xml, str)
assert feed_xml.startswith("<?xml")
# Parse XML to verify structure
root = ET.fromstring(feed_xml)
# Check namespace
assert root.tag == "{http://www.w3.org/2005/Atom}feed"
# Find required feed elements (with namespace)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
title = root.find('atom:title', ns)
assert title is not None
assert title.text == "Test Blog"
id_elem = root.find('atom:id', ns)
assert id_elem is not None
updated = root.find('atom:updated', ns)
assert updated is not None
# Check entries (should have 5 entries)
entries = root.findall('atom:entry', ns)
assert len(entries) == 5
def test_generate_atom_empty(self, app):
"""Test ATOM feed generation with no notes"""
with app.app_context():
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=[],
)
# Should still generate valid XML
assert isinstance(feed_xml, str)
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entries = root.findall('atom:entry', ns)
assert len(entries) == 0
def test_generate_atom_respects_limit(self, app, sample_notes):
"""Test ATOM feed respects entry limit"""
with app.app_context():
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=sample_notes,
limit=3,
)
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entries = root.findall('atom:entry', ns)
# Should only have 3 entries (respecting limit)
assert len(entries) == 3
def test_generate_atom_newest_first(self, app):
"""Test ATOM feed displays notes in newest-first order"""
with app.app_context():
# Create notes with distinct timestamps
for i in range(3):
create_note(
title=f"Note {i}", content=f"Content {i}.",
published=True,
)
time.sleep(0.01)
# Get notes from database (should be DESC = newest first)
notes = list_notes(published_only=True, limit=10)
# Generate feed
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=notes,
)
# Use shared helper to verify ordering
assert_feed_newest_first(feed_xml, format_type='atom', expected_count=3)
# Also verify manually with XML parsing
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entries = root.findall('atom:entry', ns)
# First entry should be newest (Note 2)
# Last entry should be oldest (Note 0)
first_title = entries[0].find('atom:title', ns).text
last_title = entries[-1].find('atom:title', ns).text
assert "Note 2" in first_title
assert "Note 0" in last_title
def test_generate_atom_requires_site_url(self):
"""Test ATOM feed generation requires site_url"""
with pytest.raises(ValueError, match="site_url is required"):
generate_atom(
site_url="",
site_name="Test Blog",
site_description="A test blog",
notes=[],
)
def test_generate_atom_requires_site_name(self):
"""Test ATOM feed generation requires site_name"""
with pytest.raises(ValueError, match="site_name is required"):
generate_atom(
site_url="https://example.com",
site_name="",
site_description="A test blog",
notes=[],
)
def test_generate_atom_entry_structure(self, app, sample_notes):
"""Test individual ATOM entry has all required elements"""
with app.app_context():
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=sample_notes[:1],
)
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entry = root.find('atom:entry', ns)
# Check required entry elements
assert entry.find('atom:id', ns) is not None
assert entry.find('atom:title', ns) is not None
assert entry.find('atom:updated', ns) is not None
assert entry.find('atom:published', ns) is not None
assert entry.find('atom:content', ns) is not None
assert entry.find('atom:link', ns) is not None
def test_generate_atom_html_content(self, app):
"""Test ATOM feed includes HTML content properly escaped"""
with app.app_context():
note = create_note(
title="Test", content="This is **bold** and *italic*.",
published=True,
)
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=[note],
)
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entry = root.find('atom:entry', ns)
content = entry.find('atom:content', ns)
# Should have type="html"
assert content.get('type') == 'html'
# Content should contain escaped HTML
content_text = content.text
assert "&lt;" in content_text or "<strong>" in content_text
def test_generate_atom_xml_escaping(self, app):
"""Test ATOM feed escapes special XML characters"""
with app.app_context():
note = create_note(
title="Test & Special <Characters>", content="Content with 'quotes' and \"doubles\".",
published=True,
)
feed_xml = generate_atom(
site_url="https://example.com",
site_name="Test Blog & More",
site_description="A test <blog>",
notes=[note],
)
# Should produce valid XML (no parse errors)
root = ET.fromstring(feed_xml)
assert root is not None
# Check title is properly escaped in XML
ns = {'atom': 'http://www.w3.org/2005/Atom'}
title = root.find('atom:title', ns)
assert title.text == "Test Blog & More"
class TestGenerateAtomStreaming:
"""Test generate_atom_streaming() function"""
def test_generate_atom_streaming_basic(self, app, sample_notes):
"""Test streaming ATOM feed generation"""
with app.app_context():
generator = generate_atom_streaming(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=sample_notes,
)
# Collect all chunks
chunks = list(generator)
assert len(chunks) > 0
# Join and verify valid XML
feed_xml = ''.join(chunks)
root = ET.fromstring(feed_xml)
ns = {'atom': 'http://www.w3.org/2005/Atom'}
entries = root.findall('atom:entry', ns)
assert len(entries) == 5
def test_generate_atom_streaming_yields_chunks(self, app, sample_notes):
"""Test streaming yields multiple chunks"""
with app.app_context():
generator = generate_atom_streaming(
site_url="https://example.com",
site_name="Test Blog",
site_description="A test blog",
notes=sample_notes,
limit=3,
)
chunks = list(generator)
# Should have multiple chunks (at least XML declaration + feed + entries + closing)
assert len(chunks) >= 4