Files
StarPunk/tests/test_search_api.py
T
PhilandClaude Opus 5.5 57b02ad6c7 feat: Crosspost notes to GoToSocial (v2.1.0)
Published notes are copied to a GoToSocial (Mastodon-API) account and
edits, unpublishing and deletes follow them (ADR-065). On by default for
new notes, untickable in the editor and selectable from Micropub via
mp-syndicate-to. A background worker reconciles each (note, target)
row with atomic claims, an idempotency key and a version so edits during
a send are not lost. Synced copies are linked with u-syndication.

Also fixes the Micropub Location header and search result links, which
pointed at /notes/<slug> (404), and the nested delete form on the edit
page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 12:46:26 -06:00

244 lines
7.5 KiB
Python

"""
Tests for search API endpoint
Tests cover:
- Search API parameter validation
- Search result formatting
- Pagination with limit and offset
- Authentication-based filtering (published/unpublished)
- FTS5 availability handling
- Error cases and edge cases
"""
import pytest
from pathlib import Path
from starpunk import create_app
from starpunk.notes import create_note
@pytest.fixture
def app(tmp_path):
"""Create test application with FTS5 enabled"""
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",
"DEV_MODE": False,
}
app = create_app(config=test_config)
return app
@pytest.fixture
def client(app):
"""Create test client"""
return app.test_client()
@pytest.fixture
def test_notes(app):
"""Create test notes for searching"""
with app.app_context():
notes = []
# Published notes
note1 = create_note(
content="# Python Tutorial\n\nLearn Python programming with examples.",
published=True
)
notes.append(note1)
note2 = create_note(
content="# JavaScript Guide\n\nModern JavaScript best practices.",
published=True
)
notes.append(note2)
note3 = create_note(
content="# Python Testing\n\nHow to write tests in Python using pytest.",
published=True
)
notes.append(note3)
# Unpublished note
note4 = create_note(
content="# Draft Python Article\n\nThis is unpublished.",
published=False
)
notes.append(note4)
return notes
def test_search_api_requires_query(client):
"""Test that search API requires a query parameter"""
response = client.get("/api/search")
assert response.status_code == 400
data = response.get_json()
assert "error" in data
assert "Missing required parameter" in data["error"]
def test_search_api_rejects_empty_query(client):
"""Test that search API rejects empty query"""
response = client.get("/api/search?q=")
assert response.status_code == 400
data = response.get_json()
assert "error" in data
def test_search_api_returns_results(client, test_notes):
"""Test that search API returns matching results"""
response = client.get("/api/search?q=python")
assert response.status_code == 200
data = response.get_json()
assert data["query"] == "python"
assert data["count"] >= 2 # Should match at least 2 Python notes
assert len(data["results"]) >= 2
# Check result structure
result = data["results"][0]
assert "slug" in result
assert "title" in result
assert "excerpt" in result
assert "published_at" in result
assert "url" in result
def test_search_api_returns_no_results_for_nonexistent(client, test_notes):
"""Test that search API returns empty results for non-matching query"""
response = client.get("/api/search?q=nonexistent")
assert response.status_code == 200
data = response.get_json()
assert data["query"] == "nonexistent"
assert data["count"] == 0
assert len(data["results"]) == 0
def test_search_api_validates_limit(client, test_notes):
"""Test that search API validates and applies limit parameter"""
# Test valid limit
response = client.get("/api/search?q=python&limit=1")
assert response.status_code == 200
data = response.get_json()
assert data["limit"] == 1
assert len(data["results"]) <= 1
# Test max limit (100)
response = client.get("/api/search?q=python&limit=1000")
assert response.status_code == 200
data = response.get_json()
assert data["limit"] == 100 # Should be capped at 100
# Test invalid limit (defaults to 20)
response = client.get("/api/search?q=python&limit=invalid")
assert response.status_code == 200
data = response.get_json()
assert data["limit"] == 20
def test_search_api_validates_offset(client, test_notes):
"""Test that search API validates offset parameter"""
response = client.get("/api/search?q=python&offset=1")
assert response.status_code == 200
data = response.get_json()
assert data["offset"] == 1
# Test invalid offset (defaults to 0)
response = client.get("/api/search?q=python&offset=-5")
assert response.status_code == 200
data = response.get_json()
assert data["offset"] == 0
def test_search_api_pagination(client, test_notes):
"""Test that search API pagination works correctly"""
# Get first page
response1 = client.get("/api/search?q=python&limit=1&offset=0")
data1 = response1.get_json()
# Get second page
response2 = client.get("/api/search?q=python&limit=1&offset=1")
data2 = response2.get_json()
# Results should be different (if there are at least 2 matches)
if data1["count"] > 0 and len(data2["results"]) > 0:
assert data1["results"][0]["slug"] != data2["results"][0]["slug"]
def test_search_api_respects_published_status(client, test_notes):
"""Test that anonymous users only see published notes"""
response = client.get("/api/search?q=draft")
assert response.status_code == 200
data = response.get_json()
# Anonymous user should not see unpublished "Draft Python Article"
assert data["count"] == 0
def test_search_api_highlights_matches(client, test_notes):
"""Test that search API includes highlighted excerpts"""
response = client.get("/api/search?q=python")
assert response.status_code == 200
data = response.get_json()
if data["count"] > 0:
# Check that excerpts contain <mark> tags for highlighting
excerpt = data["results"][0]["excerpt"]
assert "<mark>" in excerpt or "python" in excerpt.lower()
def test_search_api_handles_special_characters(client, test_notes):
"""Test that search API handles special characters in query"""
# Test quotes
response = client.get('/api/search?q="python"')
assert response.status_code == 200
# Test with URL encoding
response = client.get("/api/search?q=python%20testing")
assert response.status_code == 200
data = response.get_json()
assert data["query"] == "python testing"
def test_search_api_generates_correct_urls(client, test_notes):
"""Test that search API generates correct note URLs"""
response = client.get("/api/search?q=python")
assert response.status_code == 200
data = response.get_json()
if data["count"] > 0:
result = data["results"][0]
assert result["url"].startswith("/note/")
assert result["url"] == f"/note/{result['slug']}"
def test_search_api_provides_fallback_title(client, app):
"""Test that search API provides fallback title for notes without title"""
with app.app_context():
# Create note without clear title
note = create_note(
content="Just some content without a heading.",
published=True
)
response = client.get("/api/search?q=content")
assert response.status_code == 200
data = response.get_json()
if data["count"] > 0:
# Should have some title (either extracted or fallback)
assert data["results"][0]["title"] is not None
assert len(data["results"][0]["title"]) > 0