404 lines
14 KiB
Python
404 lines
14 KiB
Python
from datetime import timedelta
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
from django.contrib import messages
|
|
from django.contrib.messages.storage.fallback import FallbackStorage
|
|
from django.contrib.sessions.middleware import SessionMiddleware
|
|
from django.test import override_settings
|
|
from django.utils import timezone
|
|
|
|
from apps.blog.models import ArticleIndexPage, ArticlePage, ArticlePageAdminForm, Category
|
|
from apps.blog.tests.factories import AuthorFactory
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_published_date_auto_set_on_first_publish(home_page):
|
|
"""published_date should be auto-populated from first_published_at on first publish."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
article = ArticlePage(
|
|
title="Auto Date",
|
|
slug="auto-date",
|
|
author=author,
|
|
summary="summary",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
)
|
|
index.add_child(instance=article)
|
|
article.save_revision().publish()
|
|
article.refresh_from_db()
|
|
assert article.published_date is not None
|
|
assert article.published_date == article.first_published_at
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_published_date_preserved_when_explicitly_set(home_page):
|
|
"""An explicitly set published_date should not be overwritten on save."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
custom_date = timezone.now() - timedelta(days=30)
|
|
article = ArticlePage(
|
|
title="Custom Date",
|
|
slug="custom-date",
|
|
author=author,
|
|
summary="summary",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
published_date=custom_date,
|
|
)
|
|
index.add_child(instance=article)
|
|
article.save_revision().publish()
|
|
article.refresh_from_db()
|
|
assert article.published_date == custom_date
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_homepage_orders_articles_by_published_date(home_page):
|
|
"""HomePage context should list articles ordered by -published_date."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
|
|
older = ArticlePage(
|
|
title="Older",
|
|
slug="older",
|
|
author=author,
|
|
summary="s",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
published_date=timezone.now() - timedelta(days=10),
|
|
)
|
|
index.add_child(instance=older)
|
|
older.save_revision().publish()
|
|
|
|
newer = ArticlePage(
|
|
title="Newer",
|
|
slug="newer",
|
|
author=author,
|
|
summary="s",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
published_date=timezone.now(),
|
|
)
|
|
index.add_child(instance=newer)
|
|
newer.save_revision().publish()
|
|
|
|
ctx = home_page.get_context(type("Req", (), {"GET": {}})())
|
|
titles = [a.title for a in ctx["latest_articles"]]
|
|
assert titles.index("Newer") < titles.index("Older")
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_index_orders_by_published_date(home_page, rf):
|
|
"""ArticleIndexPage.get_articles should order by -published_date."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
|
|
old = ArticlePage(
|
|
title="Old",
|
|
slug="old",
|
|
author=author,
|
|
summary="s",
|
|
body=[("rich_text", "<p>b</p>")],
|
|
published_date=timezone.now() - timedelta(days=5),
|
|
)
|
|
index.add_child(instance=old)
|
|
old.save_revision().publish()
|
|
|
|
new = ArticlePage(
|
|
title="New",
|
|
slug="new",
|
|
author=author,
|
|
summary="s",
|
|
body=[("rich_text", "<p>b</p>")],
|
|
published_date=timezone.now(),
|
|
)
|
|
index.add_child(instance=new)
|
|
new.save_revision().publish()
|
|
|
|
articles = list(index.get_articles())
|
|
assert articles[0].title == "New"
|
|
assert articles[1].title == "Old"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_feed_uses_published_date(article_page):
|
|
"""RSS feed item_pubdate should use published_date."""
|
|
from apps.blog.feeds import AllArticlesFeed
|
|
|
|
feed = AllArticlesFeed()
|
|
assert feed.item_pubdate(article_page) == article_page.published_date
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_articles_listing_viewset_loads(client, django_user_model, home_page):
|
|
"""The Articles PageListingViewSet index page should load."""
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/articles/")
|
|
assert response.status_code == 200
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_articles_listing_shows_articles(client, django_user_model, home_page):
|
|
"""The Articles listing should show existing articles."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
article = ArticlePage(
|
|
title="Listed Article",
|
|
slug="listed-article",
|
|
author=author,
|
|
summary="summary",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
)
|
|
index.add_child(instance=article)
|
|
article.save_revision().publish()
|
|
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/articles/")
|
|
assert response.status_code == 200
|
|
assert "Listed Article" in response.content.decode()
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_dashboard_panel_renders(client, django_user_model, home_page):
|
|
"""The Wagtail admin dashboard should include the articles summary panel."""
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/")
|
|
assert response.status_code == 200
|
|
content = response.content.decode()
|
|
assert "Articles overview" in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_dashboard_panel_shows_drafts(client, django_user_model, home_page):
|
|
"""Dashboard panel should list draft articles."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
draft = ArticlePage(
|
|
title="My Draft Post",
|
|
slug="draft-post",
|
|
author=author,
|
|
summary="summary",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
)
|
|
index.add_child(instance=draft)
|
|
draft.save_revision() # save revision but don't publish
|
|
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/")
|
|
content = response.content.decode()
|
|
assert "My Draft Post" in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_article_edit_page_has_tabbed_interface(client, django_user_model, home_page):
|
|
"""ArticlePage editor should have tabbed panels (Content, Metadata, Publishing, SEO)."""
|
|
index = ArticleIndexPage(title="Articles", slug="articles")
|
|
home_page.add_child(instance=index)
|
|
author = AuthorFactory()
|
|
article = ArticlePage(
|
|
title="Tabbed",
|
|
slug="tabbed",
|
|
author=author,
|
|
summary="summary",
|
|
body=[("rich_text", "<p>body</p>")],
|
|
)
|
|
index.add_child(instance=article)
|
|
article.save_revision().publish()
|
|
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get(f"/cms/pages/{article.pk}/edit/")
|
|
content = response.content.decode()
|
|
assert response.status_code == 200
|
|
assert "Content" in content
|
|
assert "Metadata" in content
|
|
assert "Publishing" in content
|
|
assert "SEO" in content
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_articles_listing_has_status_filter(client, django_user_model, home_page):
|
|
"""The Articles listing should accept status filter parameter."""
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/articles/?status=live")
|
|
assert response.status_code == 200
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@override_settings(ALLOWED_HOSTS=["testserver", "localhost", "127.0.0.1"])
|
|
def test_articles_listing_has_tag_filter(client, django_user_model, home_page):
|
|
"""The Articles listing should accept tag filter parameter."""
|
|
admin = django_user_model.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="admin-pass"
|
|
)
|
|
client.force_login(admin)
|
|
response = client.get("/cms/articles/?tag=1")
|
|
assert response.status_code == 200
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_listing_default_ordering():
|
|
"""ArticlePageListingViewSet should default to -published_date ordering."""
|
|
from apps.blog.wagtail_hooks import ArticlePageListingViewSet
|
|
|
|
assert ArticlePageListingViewSet.default_ordering == "-published_date"
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_search_fields_include_summary():
|
|
"""ArticlePage.search_fields should index the summary field."""
|
|
field_names = [
|
|
f.field_name for f in ArticlePage.search_fields if hasattr(f, "field_name")
|
|
]
|
|
assert "summary" in field_names
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_admin_form_relaxes_initial_required_fields(article_index, django_user_model):
|
|
"""Slug/author/category/summary should not block initial draft validation."""
|
|
user = django_user_model.objects.create_user(
|
|
username="writer",
|
|
email="writer@example.com",
|
|
password="writer-pass",
|
|
)
|
|
form_class = ArticlePage.get_edit_handler().get_form_class()
|
|
form = form_class(parent_page=article_index, for_user=user)
|
|
|
|
assert form.fields["slug"].required is False
|
|
assert form.fields["author"].required is False
|
|
assert form.fields["category"].required is False
|
|
assert form.fields["summary"].required is False
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_admin_form_clean_applies_defaults(article_index, django_user_model, monkeypatch):
|
|
"""Form clean should populate defaults before parent validation runs."""
|
|
user = django_user_model.objects.create_user(
|
|
username="writer",
|
|
email="writer@example.com",
|
|
password="writer-pass",
|
|
first_name="Writer",
|
|
last_name="User",
|
|
)
|
|
form_class = ArticlePage.get_edit_handler().get_form_class()
|
|
form = form_class(parent_page=article_index, for_user=user)
|
|
|
|
body = [
|
|
SimpleNamespace(block_type="code", value=SimpleNamespace(raw_code="print('ignore')")),
|
|
SimpleNamespace(block_type="rich_text", value=SimpleNamespace(source="<p>Hello world body text.</p>")),
|
|
]
|
|
form.cleaned_data = {
|
|
"title": "Auto Defaults Title",
|
|
"slug": "",
|
|
"author": None,
|
|
"category": None,
|
|
"summary": "",
|
|
"body": body,
|
|
}
|
|
observed = {}
|
|
|
|
def fake_super_clean(_self):
|
|
observed["slug_before_parent_clean"] = _self.cleaned_data.get("slug")
|
|
return _self.cleaned_data
|
|
|
|
mro = form.__class__.__mro__
|
|
super_form_class = mro[mro.index(ArticlePageAdminForm) + 1]
|
|
monkeypatch.setattr(super_form_class, "clean", fake_super_clean)
|
|
cleaned = form.clean()
|
|
|
|
assert observed["slug_before_parent_clean"] == "auto-defaults-title"
|
|
assert cleaned["slug"] == "auto-defaults-title"
|
|
assert cleaned["author"] is not None
|
|
assert cleaned["author"].user_id == user.id
|
|
assert cleaned["category"] is not None
|
|
assert cleaned["category"].slug == "general"
|
|
assert cleaned["summary"] == "Hello world body text."
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_seo_tab_fields_not_duplicated():
|
|
"""SEO tab should include each promote/SEO field only once."""
|
|
handler = ArticlePage.get_edit_handler()
|
|
seo_tab = next(panel for panel in handler.children if panel.heading == "SEO")
|
|
|
|
def flatten_field_names(panel):
|
|
names = []
|
|
for child in panel.children:
|
|
if hasattr(child, "field_name"):
|
|
names.append(child.field_name)
|
|
else:
|
|
names.extend(flatten_field_names(child))
|
|
return names
|
|
|
|
field_names = flatten_field_names(seo_tab)
|
|
assert field_names.count("slug") == 1
|
|
assert field_names.count("seo_title") == 1
|
|
assert field_names.count("search_description") == 1
|
|
assert field_names.count("show_in_menus") == 1
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_save_autogenerates_summary_when_missing(article_index):
|
|
"""Model save fallback should generate summary from prose blocks."""
|
|
category = Category.objects.create(name="Guides", slug="guides")
|
|
author = AuthorFactory()
|
|
article = ArticlePage(
|
|
title="Summary Auto",
|
|
slug="summary-auto",
|
|
author=author,
|
|
category=category,
|
|
summary="",
|
|
body=[
|
|
("code", {"language": "python", "filename": "", "raw_code": "print('skip')"}),
|
|
("rich_text", "<p>This should become the summary text.</p>"),
|
|
],
|
|
)
|
|
|
|
article_index.add_child(instance=article)
|
|
article.save()
|
|
|
|
assert article.summary == "This should become the summary text."
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_article_page_omits_admin_messages_on_frontend(article_page, rf):
|
|
"""Frontend templates should not render admin session messages."""
|
|
request = rf.get(article_page.url)
|
|
SessionMiddleware(lambda req: None).process_request(request)
|
|
request.session.save()
|
|
setattr(request, "_messages", FallbackStorage(request))
|
|
messages.success(request, "Page 'Test' has been published.")
|
|
|
|
response = article_page.serve(request)
|
|
response.render()
|
|
content = response.content.decode()
|
|
|
|
assert "Page 'Test' has been published." not in content
|
|
assert 'aria-label="Messages"' not in content
|