bruks/dynamicweb
1
0
Fork 0
forked from ungleich-public/dynamicweb
Code Pull requests Activity
dynamicweb/cms/tests/test_grouper_admin.py

1414 lines
66 KiB
Python
Raw Blame History

import copy
from unittest.mock import MagicMock, patch
from django.conf import settings
from django.contrib.admin import site
from django.contrib.auth import get_permission_codename
from django.contrib.sites.models import Site
from django.db import connection
from django.templatetags.static import static
from django.test.utils import CaptureQueriesContext
from django.utils.crypto import get_random_string
from django.utils.translation import get_language, override as force_language
from cms.admin.utils import CONTENT_PREFIX, GrouperModelAdmin
from cms.test_utils.project.sampleapp.models import (
GrouperModel,
GrouperModelContent,
SimpleGrouperModel,
SimpleGrouperModelContent,
)
from cms.test_utils.testcases import CMSTestCase
from cms.test_utils.util.grouper import wo_content_permission
from cms.utils.i18n import get_language_list
from cms.utils.urlutils import admin_reverse, static_with_version
class SetupMixin:
"""Create one grouper object and retrieve the admin instance"""
def setUp(self) -> None:
self.grouper_instance = GrouperModel.objects.create(category_name="Grouper Category")
self.add_url = admin_reverse("sampleapp_groupermodel_add")
self.change_url = admin_reverse("sampleapp_groupermodel_change", args=(self.grouper_instance.pk,))
self.changelist_url = admin_reverse("sampleapp_groupermodel_changelist")
self.admin_user = self.get_superuser()
self.admin = site._registry[GrouperModel]
self.groupermodel = "groupermodel"
self.grouper_model = "grouper_model"
def tearDown(self) -> None:
self.grouper_instance.delete()
self.admin.clear_content_cache() # The admin does this automatically for each new request.
def createContentInstance(self, language="en"):
"""Creates a content instance with a random content for a language. The random content is returned
to be able to check if it appears in forms etc."""
instance = GrouperModelContent.objects.create(
grouper_model=self.grouper_instance,
language=language,
secret_greeting=get_random_string(16),
)
self.admin.clear_content_cache() # The admin does this automatically for each new request.
return instance
class SimpleSetupMixin:
"""Create one grouper object and retrieve the admin instance"""
def setUp(self) -> None:
self.grouper_instance = SimpleGrouperModel.objects.create(category_name="Grouper Category")
self.add_url = admin_reverse("sampleapp_simplegroupermodel_add")
self.change_url = admin_reverse("sampleapp_simplegroupermodel_change", args=(self.grouper_instance.pk,))
self.changelist_url = admin_reverse("sampleapp_simplegroupermodel_changelist")
self.admin_user = self.get_superuser()
self.admin = site._registry[SimpleGrouperModel]
self.groupermodel = "simplegroupermodel"
self.grouper_model = "simple_grouper_model"
def tearDown(self) -> None:
self.grouper_instance.delete()
self.admin.clear_content_cache() # The admin does this automatically for each new request.
def createContentInstance(self, language="en", grouper_instance=None, secret_greeting=None):
"""Creates a content instance with a random content for a language. The random content is returned
to be able to check if it appears in forms etc."""
assert language == "en", "Only English is supported for SimpleGrouperModelContent"
grouper_instance = grouper_instance or self.grouper_instance
secret_greeting = secret_greeting or get_random_string(16)
instance = SimpleGrouperModelContent.objects.create(
simple_grouper_model=grouper_instance,
secret_greeting=secret_greeting,
)
self.admin.clear_content_cache() # The admin does this automatically for each new request.
return instance
class SimpleChangeListActionsTestCase(SimpleSetupMixin, CMSTestCase):
def test_action_js_css(self):
"""Are js and css files loaded?
The js and css files are supposed to be arranged by the GrouperAdminMixin."""
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(f"{self.changelist_url}?", follow=True)
# Assert
self.assertContains(response, static("admin/js/jquery.init.js"))
self.assertContains(response, static("cms/js/admin/actions.js"))
self.assertContains(response, static_with_version("cms/css/cms.admin.css"))
def test_add_action(self):
"""Change list offers an add button if no content object exists for grouper.
The button is supposed to be arranged by the GrouperAdminMixin."""
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(f"{self.changelist_url}?language=en", follow=True)
# Assert
self.assertContains(response, 'class="cms-icon cms-icon-plus"')
self.assertContains(
response, f'href="/en/admin/sampleapp/{self.groupermodel}/{self.grouper_instance.pk}/change/?'
)
self.assertNotContains(response, 'class="cms-icon cms-icon-view"')
def test_change_action(self):
"""Change list offers a settings button if content object exists for grouper"""
# Arrange
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(f"{self.changelist_url}?language=en", follow=True)
# Assert
self.assertNotContains(response, 'class="cms-icon cms-icon-view"') # Not frontend-editable
self.assertContains(
response, f'href="/en/admin/sampleapp/{self.groupermodel}/{self.grouper_instance.pk}/change/?'
)
def test_get_action(self):
admin = site._registry[GrouperModel]
get_action = admin.admin_action_button(
"/some/url",
icon="info",
title="Info",
action="get",
)
self.assertIn("cms-form-get-method", get_action)
self.assertNotIn("cms-form-post-method", get_action)
def test_post_action(self):
admin = site._registry[GrouperModel]
get_action = admin.admin_action_button(
"/some/url",
icon="bin",
title="Delete",
action="post",
)
self.assertNotIn("cms-form-get-method", get_action)
self.assertIn("cms-form-post-method", get_action)
class ChangeListActionsTestCase(SetupMixin, SimpleChangeListActionsTestCase):
pass
class GrouperModelAdminTestCase(SetupMixin, CMSTestCase):
def get_list_editable_post_data(self, response, **values):
formset = response.context["cl"].formset
data = {
"form-TOTAL_FORMS": formset.total_form_count(),
"form-INITIAL_FORMS": formset.initial_form_count(),
"form-MIN_NUM_FORMS": formset.min_num,
"form-MAX_NUM_FORMS": formset.max_num,
"_save": "Save",
}
for index, form in enumerate(formset.forms):
data[f"form-{index}-id"] = form.instance.pk
for field_name in self.admin.list_editable:
data[f"form-{index}-{field_name}"] = values.get(field_name, form[field_name].value())
data[f"form-{index}-_content_object_id"] = form["_content_object_id"].value() or ""
return data
def test_list_editable_saves_grouper_field(self):
with (
patch.object(self.admin, "list_display", ("category_name",)),
patch.object(self.admin, "list_display_links", None),
patch.object(self.admin, "list_editable", ("category_name",)),
self.login_user_context(self.admin_user),
):
response = self.client.get(f"{self.changelist_url}?language=en")
data = self.get_list_editable_post_data(response, category_name="Changed grouper")
response = self.client.post(f"{self.changelist_url}?language=en", data)
self.assertEqual(response.status_code, 302)
self.grouper_instance.refresh_from_db()
self.assertEqual(self.grouper_instance.category_name, "Changed grouper")
def test_list_editable_saves_content_field_for_current_grouping(self):
english_content = self.createContentInstance("en")
german_content = self.createContentInstance("de")
with (
patch.object(self.admin, "list_display", ("category_name", "content__secret_greeting")),
patch.object(self.admin, "list_editable", ("content__secret_greeting",)),
self.login_user_context(self.admin_user),
):
response = self.client.get(f"{self.changelist_url}?language=de")
self.assertContains(response, 'name="form-0-_content_object_id"')
data = self.get_list_editable_post_data(response, content__secret_greeting="Guten Tag")
response = self.client.post(f"{self.changelist_url}?language=de", data)
self.assertEqual(response.status_code, 302)
english_content.refresh_from_db()
german_content.refresh_from_db()
self.assertNotEqual(english_content.secret_greeting, "Guten Tag")
self.assertEqual(german_content.secret_greeting, "Guten Tag")
def test_list_editable_saves_grouper_and_content_fields(self):
content = self.createContentInstance("en")
with (
patch.object(self.admin, "list_display", ("category_name", "content__secret_greeting")),
patch.object(self.admin, "list_display_links", None),
patch.object(self.admin, "list_editable", ("category_name", "content__secret_greeting")),
self.login_user_context(self.admin_user),
):
response = self.client.get(f"{self.changelist_url}?language=en")
data = self.get_list_editable_post_data(
response,
category_name="Changed grouper",
content__secret_greeting="Changed content",
)
response = self.client.post(f"{self.changelist_url}?language=en", data)
self.assertEqual(response.status_code, 302)
self.grouper_instance.refresh_from_db()
content.refresh_from_db()
self.assertEqual(self.grouper_instance.category_name, "Changed grouper")
self.assertEqual(content.secret_greeting, "Changed content")
def test_list_editable_creates_content_for_current_grouping(self):
with (
patch.object(self.admin, "list_display", ("category_name", "content__secret_greeting")),
patch.object(self.admin, "list_editable", ("content__secret_greeting",)),
self.login_user_context(self.admin_user),
):
response = self.client.get(f"{self.changelist_url}?language=de")
data = self.get_list_editable_post_data(response, content__secret_greeting="Guten Tag")
response = self.client.post(f"{self.changelist_url}?language=de", data)
self.assertEqual(response.status_code, 302)
content = GrouperModelContent.objects.get(grouper_model=self.grouper_instance)
self.assertEqual(content.language, "de")
self.assertEqual(content.secret_greeting, "Guten Tag")
def test_list_editable_rejects_content_from_another_grouper(self):
self.createContentInstance("en")
other_grouper = GrouperModel.objects.create(category_name="Other")
other_content = GrouperModelContent.objects.create(
grouper_model=other_grouper,
language="en",
secret_greeting="Other greeting",
)
with (
patch.object(self.admin, "list_display", ("category_name", "content__secret_greeting")),
patch.object(self.admin, "list_editable", ("content__secret_greeting",)),
self.login_user_context(self.admin_user),
):
response = self.client.get(f"{self.changelist_url}?language=en")
data = self.get_list_editable_post_data(response, content__secret_greeting="Tampered")
form_index = next(
index
for index, form in enumerate(response.context["cl"].formset.forms)
if form.instance.pk == self.grouper_instance.pk
)
data[f"form-{form_index}-_content_object_id"] = other_content.pk
response = self.client.post(f"{self.changelist_url}?language=en", data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "The selected content does not match this object and grouping.")
other_content.refresh_from_db()
self.assertEqual(other_content.secret_greeting, "Other greeting")
def test_form_class_created(self):
"""The form class has automatically been enhanced with the GrouperAdminFormMixin for
the appropriate content model (actually its parent class _GrouperAdminFormMixin)"""
# Arrange
from cms.admin.utils import _GrouperAdminFormMixin
# Assert
self.assertTrue(issubclass(self.admin.form, _GrouperAdminFormMixin))
self.assertEqual(self.admin.form._content_model, GrouperModelContent)
def test_content_field_is_valid_in_list_editable(self):
admin = copy.copy(self.admin)
admin.list_display = ("category_name", "content__secret_greeting")
admin.list_editable = ("content__secret_greeting",)
self.assertEqual(admin.check(), [])
def test_grouping_field_is_invalid_in_list_editable(self):
admin = copy.copy(self.admin)
admin.list_display = ("category_name", "content__language")
admin.list_editable = ("content__language",)
errors = admin.check()
self.assertIn("admin.E125", [error.id for error in errors])
def test_form_class_content_fields(self):
"""The content fields appear in the admin form with a prefix"""
# Assert
for field in self.admin.form._content_fields:
self.assertIn(CONTENT_PREFIX + field, self.admin.form.base_fields)
def test_content_model_detected(self) -> None:
"""Content model has been detected correctly for grouper admin"""
# Assert
admin = site._registry[GrouperModel]
self.assertEqual(admin.content_model, GrouperModelContent)
def test_extra_grouping_field_fixed(self):
"""Extra grouping fields are retrieved correctly"""
with force_language("en"):
expected_language = "zh"
self.admin.language = expected_language
admin_language = self.admin.get_language()
current_content_filters = self.admin.current_content_filters
self.assertEqual(admin_language, expected_language)
self.assertEqual(current_content_filters["language"], expected_language)
def test_extra_grouping_field_current(self):
"""Extra grouping fields (language) when not set return current default correctly"""
del self.admin.language # No pre-set language
expected_language = get_language()
admin_language = self.admin.get_language()
current_content_filters = self.admin.current_content_filters
self.assertEqual(admin_language, expected_language)
self.assertEqual(current_content_filters["language"], expected_language)
def test_prepopulated_fields_pass_checks(self):
"""Prepopulated fields work for content field"""
# Arrange
admin = copy.copy(self.admin)
admin.prepopulated_fields = dict(
category_name=["category_name"], # Both key and value from GrouperModel
some_field=["content__secret_greeting"], # Value from ContentModel
content__secret_greeting=["category_name"], # Key from GrouperModel
content__region=["content__secret_greeting"], # Both key and value from ContentModel
)
# Act
check_results = admin.check()
# Assert
self.assertEqual(check_results, []) # No errors
def test_invalid_prepopulated_content_fields_fail_checks(self):
"""Prepopulated fields with invalid content field names fail checks"""
# Arrange
admin = copy.copy(self.admin)
admin.prepopulated_fields = dict(
some_field=["content__public_greeting"], # Value from ContentModel: 1 error
content__public_greeting=["category_name"], # Key from GrouperModel: 1 error
content__country=["content__public_greeting"], # Both key and value from ContentModel: 2 errors
)
# Act
check_results = admin.check()
# Assert
self.assertEqual(len(check_results), 4) # 4 errors expected (see above)
@wo_content_permission
def test_prepopulated_fields_exclude_readonly_fields(self):
"""Read-only fields are removed from prepopulated field keys."""
# Arrange
admin = copy.copy(self.admin)
admin.prepopulated_fields = {
"content__secret_greeting": ["category_name"],
"category_name": ["content__secret_greeting"],
}
# Act
readonly_fields = admin.get_readonly_fields(None)
prepopulated = admin.get_prepopulated_fields(None)
# Assert
self.assertIn("content__secret_greeting", readonly_fields)
self.assertNotIn("content__secret_greeting", prepopulated)
self.assertIn("category_name", prepopulated)
# The class attribute is not mutated by get_readonly_fields/get_prepopulated_fields.
self.assertIn("content__secret_greeting", admin.prepopulated_fields)
def test_prepopulated_fields_respects_class_attribute_after_init(self):
"""``cls.prepopulated_fields`` set after the admin is instantiated is honored."""
# Arrange
admin = copy.copy(self.admin)
admin.prepopulated_fields = {"category_name": ["content__secret_greeting"]}
# Act
prepopulated = admin.get_prepopulated_fields(None)
# Assert: no shadow instance attribute hides the class-level value.
self.assertEqual(prepopulated, {"category_name": ["content__secret_greeting"]})
def test_changelist_view_does_not_call_get_content_obj(self):
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
with patch.object(self.admin, "get_content_obj", wraps=self.admin.get_content_obj) as mocked_get_content_obj:
response = self.client.get(f"{self.changelist_url}?language=en", follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(mocked_get_content_obj.call_count, 0)
def test_change_view_calls_get_content_obj(self):
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
with patch.object(self.admin, "get_content_obj", wraps=self.admin.get_content_obj) as mocked_get_content_obj:
response = self.client.get(f"{self.change_url}?language=en", follow=True)
self.assertEqual(response.status_code, 200)
self.assertGreater(mocked_get_content_obj.call_count, 0)
self.assertTrue(any(call.args and call.args[0] == self.grouper_instance for call in mocked_get_content_obj.call_args_list))
def test_get_content_obj_caches_on_grouper_object(self):
content_instance = self.createContentInstance("en")
self.admin.language = "en"
self.admin.clear_content_cache()
self.assertFalse(hasattr(self.grouper_instance, "_grouper_admin_content_obj_cache"))
with self.assertNumQueries(1):
cached_content = self.admin.get_content_obj(self.grouper_instance)
self.assertEqual(cached_content, content_instance)
self.assertTrue(hasattr(self.grouper_instance, "_grouper_admin_content_obj_cache"))
with self.assertNumQueries(0):
cached_again = self.admin.get_content_obj(self.grouper_instance)
self.assertIs(cached_again, cached_content)
class GrouperChangeListTestCase(SetupMixin, CMSTestCase):
def test_language_selector(self):
"""All languages available to select"""
# Act
with self.login_user_context(self.admin_user):
response = self.client.get(self.changelist_url)
# Assert
for lang, verb in self.admin.get_language_tuple(site=Site.objects.get_current()):
self.assertContains(response, f'<option value="{lang}"')
def test_empty_content(self) -> None:
"""Without any content being created the changelist shows an empty content text"""
with self.login_user_context(self.admin_user):
for language in ("en", "de", "it"):
# Act
response = self.client.get(self.changelist_url + f"?language={language}")
# Assert
self.assertContains(response, "Empty content")
def test_with_content(self) -> None:
"""Create one content object and see if it appears in the right admin"""
# Arrange
random_content = self.createContentInstance("de")
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.changelist_url + "?language=de")
# Assert
self.assertContains(response, "Grouper Category")
self.assertContains(response, random_content.secret_greeting)
for language in ("en", "it"):
# Act
response = self.client.get(self.changelist_url + f"?language={language}")
# Assert
self.assertContains(response, "Empty content")
def test_with_content_only(self) -> None:
"""Create one content object and see if it appears in the right admin"""
# Arrange
random_content = {
lang: self.createContentInstance(lang).secret_greeting for lang in get_language_list(site_id=settings.SITE_ID)
}
with self.login_user_context(self.admin_user):
for language in get_language_list(site_id=Site.objects.get_current().pk):
# Act
response = self.client.get(self.changelist_url + f"?language={language}")
# Assert
self.assertContains(response, "Grouper Category")
self.assertContains(response, random_content[language])
def test_get_content_obj_uses_prefetch_cache(self) -> None:
"""Iterating the admin queryset and calling ``get_content_obj`` on each grouper must
not issue per-row queries — the prefetch registered in ``get_queryset`` is expected
to populate ``_admin_prefetch_cache``, so the total query count stays constant."""
# Arrange: baseline + many grouper/content pairs.
self.createContentInstance("en")
for i in range(10):
extra = GrouperModel.objects.create(category_name=f"Grouper {i}")
GrouperModelContent.objects.create(
grouper_model=extra, language="en", secret_greeting=f"Greeting {i}"
)
request = self.get_request()
request.user = self.admin_user
self.admin.language = "en"
# Act: mimic what the changelist does — materialize the queryset, then look up
# each grouper's content object.
with CaptureQueriesContext(connection) as ctx:
groupers = list(self.admin.get_queryset(request))
for grouper in groupers:
self.assertIsNotNone(self.admin.get_content_obj(grouper))
# Assert: one query for groupers + one for the prefetch = 2.
# Without the prefetch we'd see 1 + N queries (12 here).
self.assertLessEqual(
len(ctx),
3,
f"Expected ≤ 3 queries for 11 groupers thanks to prefetch_related, got {len(ctx)}. "
f"Looks like ``get_content_obj`` is not using the prefetch cache.",
)
def test_changelist_view_has_no_n_plus_1(self) -> None:
"""End-to-end regression guard: the query count of the changelist HTTP view must
not grow with the number of grouper instances. Protects against future n+1s
introduced by list_display getters, action buttons, or related hooks."""
# Arrange: baseline with a single grouper (from setUp) + one content object.
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
# Warm up the client/session so login-related queries don't pollute counts.
self.client.get(self.changelist_url + "?language=en")
with CaptureQueriesContext(connection) as baseline:
response = self.client.get(self.changelist_url + "?language=en")
self.assertEqual(response.status_code, 200)
# Act: add many more grouper/content pairs.
for i in range(10):
extra = GrouperModel.objects.create(category_name=f"Grouper {i}")
GrouperModelContent.objects.create(
grouper_model=extra, language="en", secret_greeting=f"Greeting {i}"
)
with CaptureQueriesContext(connection) as scaled:
response = self.client.get(self.changelist_url + "?language=en")
self.assertEqual(response.status_code, 200)
# Assert: query count is invariant to number of rows.
self.assertEqual(
len(baseline),
len(scaled),
f"Changelist issued {len(baseline)} queries for 1 grouper but {len(scaled)} for 11. "
f"This suggests an n+1 has been introduced.",
)
class SimpleGrouperChangeListTestCase(SimpleSetupMixin, CMSTestCase):
def test_mixed_change_form(self):
"""Change form contains input for both grouper and content objects"""
# Arrange
random_content = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(f"{self.change_url}?language=en", follow=True)
# Assert
# Contains relation to grouper as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__simple_grouper_model"',
)
# Contains grouper field with category (and its value)
self.assertContains(
response,
'<input type="text" name="category_name" value="Grouper Category"',
)
# Contains content secret message as textarea
self.assertContains(response, '<textarea name="content__secret_greeting"')
self.assertContains(response, random_content.secret_greeting)
def test_empty_content(self) -> None:
"""Without any content being created the changelist shows an empty content text"""
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.changelist_url)
# Assert
self.assertContains(response, "Empty content")
def test_with_content(self) -> None:
"""Create one content object and see if it appears in the admin"""
# Arrange
random_content = self.createContentInstance()
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.changelist_url)
# Assert
self.assertContains(response, "Grouper Category")
self.assertContains(response, random_content.secret_greeting)
def test_no_language_selector_without_extra_grouping_field(self) -> None:
"""No language selector is shown when no extra grouping field exists."""
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.changelist_url)
# Assert
self.assertNotContains(response, 'class="language-selector"')
self.assertNotContains(response, 'class="language-selector js-language-selector"')
class GrouperChangeTestCase(SetupMixin, CMSTestCase):
def test_mixed_change_form(self):
"""Change form contains input for both grouper and content objects"""
# Arrange
random_content = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(f"{self.change_url}?language=en", follow=True)
# Assert
# Contains relation to grouper as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__grouper_model"',
)
# Contains extra grouping field as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__language" value="en" id="id_content__language">',
)
# Contains grouper field with category (and its value)
self.assertContains(
response,
'<input type="text" name="category_name" value="Grouper Category"',
)
# Contains content secret message as textarea
self.assertContains(response, '<textarea name="content__secret_greeting"')
self.assertContains(response, random_content.secret_greeting)
def test_change_form_contains_defaults_for_groupers(self) -> None:
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.change_url + "?language=en", follow=True)
# Assert
self.assertContains(response, 'name="content__language" value="en"')
self.assertNotContains(response, 'name="content__language" value="de"')
# Act
response = self.client.get(self.change_url + "?language=de")
# Assert
self.assertContains(response, 'name="content__language" value="de"')
self.assertNotContains(response, 'name="content__language" value="en"')
def test_is_latest_content_obj(self) -> None:
"""The latest content object is recognized as such, a stale one is not, and the
add view (no content object) counts as latest."""
content = self.createContentInstance("en")
self.admin.language = "en"
try:
# The actual content object is the latest
self.assertTrue(self.admin.is_latest_content_obj(content, self.grouper_instance))
# A stale content object (different pk) is not the latest
stale = copy.copy(content)
stale.pk = content.pk + 1000
self.assertFalse(self.admin.is_latest_content_obj(stale, self.grouper_instance))
# The add view (no content object) always counts as latest
self.assertTrue(self.admin.is_latest_content_obj(None))
finally:
del self.admin.language
def test_language_selector_shown_for_latest_content(self) -> None:
"""The change form offers the language selector when the latest content is shown."""
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(self.change_url + "?language=en")
self.assertContains(response, 'id="page_form_lang_tabs"')
def test_language_selector_hidden_for_non_latest_content(self) -> None:
"""The change form drops the language selector when an older (non-latest) content
object is shown. Switching languages back and forth would otherwise silently bring
up the latest content instead - confusing UX."""
content = self.createContentInstance("en")
# Simulate a versioning package that shows an older (non-latest) content object
stale = copy.copy(content)
stale.pk = content.pk + 1000
with patch.object(type(self.admin), "get_content_obj", return_value=stale):
with self.login_user_context(self.admin_user):
response = self.client.get(self.change_url + "?language=en")
self.assertNotContains(response, 'id="page_form_lang_tabs"')
def test_get_urls_declares_content_change_when_unregistered(self) -> None:
"""The grouper admin provides a change URL for the (unregistered) content model."""
names = [url.name for url in self.admin.get_urls()]
self.assertIn("sampleapp_groupermodelcontent_change", names)
def test_get_urls_skips_content_change_when_registered(self) -> None:
"""The declaration is dropped when the content model has its own admin."""
site.register(GrouperModelContent)
try:
names = [url.name for url in self.admin.get_urls()]
self.assertNotIn("sampleapp_groupermodelcontent_change", names)
finally:
site.unregister(GrouperModelContent)
def test_content_change_url_redirects_to_grouper(self) -> None:
"""A content object's change URL redirects to the grouper change view, selecting that
specific content object and its grouping fields."""
param = self.admin.content_pk_url_param
content = self.createContentInstance("en")
content_change_url = admin_reverse("sampleapp_groupermodelcontent_change", args=(content.pk,))
with self.login_user_context(self.admin_user):
response = self.client.get(content_change_url)
self.assertEqual(response.status_code, 302)
self.assertTrue(response.url.startswith(self.change_url))
self.assertIn(f"{param}={content.pk}", response.url)
self.assertIn("language=en", response.url)
def test_content_change_redirect_rejects_post(self) -> None:
"""The redirect view is GET-only: a POST is rejected (405) rather than silently turned
into a GET that discards its payload."""
content = self.createContentInstance("en")
content_change_url = admin_reverse("sampleapp_groupermodelcontent_change", args=(content.pk,))
with self.login_user_context(self.admin_user):
response = self.client.post(content_change_url, data={"category_name": "changed"})
self.assertEqual(response.status_code, 405)
def test_specific_content_obj_shown_and_selector_dropped(self) -> None:
"""Requesting a specific (non-latest) content object by pk shows exactly that object and
drops the language selector."""
param = self.admin.content_pk_url_param
latest = self.createContentInstance("en") # lower pk: picked as latest by .first()
other = self.createContentInstance("en") # higher pk: a different content object
with self.login_user_context(self.admin_user):
response = self.client.get(f"{self.change_url}?{param}={other.pk}")
# The requested (non-latest) content object is shown ...
self.assertContains(response, other.secret_greeting)
self.assertNotContains(response, latest.secret_greeting)
# ... and the language selector is dropped because it is not the latest content
self.assertNotContains(response, 'id="page_form_lang_tabs"')
def test_specific_latest_content_obj_keeps_selector(self) -> None:
"""Requesting the latest content object by pk shows it and keeps the language selector."""
param = self.admin.content_pk_url_param
latest = self.createContentInstance("en") # lower pk: picked as latest by .first()
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(f"{self.change_url}?{param}={latest.pk}")
self.assertContains(response, latest.secret_greeting)
self.assertContains(response, 'id="page_form_lang_tabs"')
def test_invalid_content_pk_falls_back_to_latest(self) -> None:
"""An invalid content pk is ignored and the latest content is shown."""
param = self.admin.content_pk_url_param
content = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(f"{self.change_url}?language=en&{param}=not-a-pk")
self.assertContains(response, content.secret_greeting)
self.assertContains(response, 'id="page_form_lang_tabs"')
def test_nonexistent_content_pk_falls_back_to_latest(self) -> None:
"""A syntactically valid but nonexistent content pk falls back to the latest content."""
param = self.admin.content_pk_url_param
content = self.createContentInstance("en")
nonexistent_pk = content.pk + 1
with self.login_user_context(self.admin_user):
response = self.client.get(
f"{self.change_url}?language=en&{param}={nonexistent_pk}"
)
self.assertContains(response, content.secret_greeting)
self.assertContains(response, 'id="page_form_lang_tabs"')
@wo_content_permission
def test_change_form_wo_write_permit(self) -> None:
"""If no change permission exists for content mark content fields readonly."""
# Arrange
random_content = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
# Act
response = self.client.get(self.change_url + "?language=en")
# Assert
# Contains relation to grouper as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__grouper_model"',
)
# Contains extra grouping field as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__language" value="en" id="id_content__language">',
)
# Contains extra grouping field as hidden input
self.assertContains(
response,
'<input type="hidden" name="content__language" value="en" id="id_content__language">',
)
# Contains grouper field with category (and its value)
self.assertContains(response, '<input type="text" name="category_name" value="Grouper Category"')
# Does not contain content secret message as textarea
self.assertContains(response, 'field-content__secret_greeting"')
self.assertContains(response, random_content.secret_greeting)
def test_admin_with_write_permit(self) -> None:
"""If change permissions exist for content model its fields in the admin are not readonly."""
# Assert
self.assertNotIn("content__secret_greeting", self.admin.get_readonly_fields(None))
@wo_content_permission
def test_admin_wo_write_permit(self) -> None:
# Assert
self.assertIn("content__secret_greeting", self.admin.get_readonly_fields(None))
def test_save_grouper_model(self) -> None:
# Arrange
random_content = self.createContentInstance("en")
data = {
"content__language": "en",
"category_name": "Changed content",
"some_field": "some content",
"content__region": "world",
"content__secret_greeting": random_content.secret_greeting,
}
with self.login_user_context(self.admin_user):
# Act
response = self.client.post(self.change_url + "?language=en", data=data)
# Assert
self.grouper_instance.refresh_from_db()
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertEqual(self.grouper_instance.category_name, data["category_name"])
def test_save_content_model(self) -> None:
# Arrange
self.createContentInstance("en")
data = {
"content__language": "en",
"category_name": self.grouper_instance.category_name,
"some_field": "some content",
"content__region": "world",
"content__secret_greeting": "New greeting",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.change_url + "?language=en", data=data)
content_instance = GrouperModelContent.objects.filter(language="en").first()
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertIsNotNone(content_instance)
self.assertEqual(content_instance.secret_greeting, data["content__secret_greeting"])
def test_create_grouper_model(self) -> None:
# Arrange
data = {
"content__language": "de",
"category_name": "My new category",
"some_field": "some content",
"content__region": "world",
"content__secret_greeting": "Some new content",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.add_url + "?language=de", data=data)
grouper_instance = GrouperModel.objects.filter(category_name=data["category_name"]).first()
content_instance_en = grouper_instance.groupermodelcontent_set.filter(language="en").first() # Get English
content_instance_de = grouper_instance.groupermodelcontent_set.filter(language="de").first() # Get German
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertEqual(GrouperModel.objects.all().count(), 2)
self.assertIsNotNone(grouper_instance)
self.assertIsNone(content_instance_en) # Should not exist
self.assertIsNotNone(content_instance_de) # Should exist
self.assertEqual(content_instance_de.secret_greeting, data["content__secret_greeting"]) # Has new content
def test_create_content_model(self) -> None:
# Arrange
random_content = self.createContentInstance("en")
data = {
"content__language": "de",
"category_name": self.grouper_instance.category_name,
"some_field": "some content",
"content__region": "world",
"content__secret_greeting": "New German content",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.change_url + "?language=de", data=data)
content_instance_en = GrouperModelContent.objects.filter(language="en").first() # Get English
content_instance_de = GrouperModelContent.objects.filter(language="de").first() # New German instance
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertIsNotNone(content_instance_en)
self.assertEqual(content_instance_en.secret_greeting, random_content.secret_greeting) # unchanged
self.assertIsNotNone(content_instance_de) # Exists?
self.assertEqual(content_instance_de.secret_greeting, data["content__secret_greeting"]) # Has new content
class SimpleGrouperContentSelectionTestCase(SimpleSetupMixin, CMSTestCase):
"""The content object selected by :attr:`GrouperModelAdmin.content_pk_url_param` has to survive
the change form's submission: the form is posted to the url built from the preserved filters,
and "save and continue editing" returns to it."""
def get_change_form(self, content_obj, **values) -> tuple[str, dict]:
"""Open the change form for a specific content object and return the url it is submitted
to together with the data of a full submission (mimicking the rendered form)."""
param = self.admin.content_pk_url_param
response = self.client.get(f"{self.change_url}?{param}={content_obj.pk}")
self.assertEqual(response.status_code, 200)
form = response.context["adminform"].form
data = {}
for name, field in form.fields.items():
value = form.initial.get(name, field.initial)
value = getattr(value, "pk", value)
if field.required and value in (None, ""):
value = "some content"
data[name] = "" if value is None else value
data[f"{CONTENT_PREFIX}secret_greeting"] = "Changed content"
data.update(values)
return self.change_url + response.context["form_url"], data
def test_change_form_saves_requested_content_obj(self) -> None:
"""Saving writes to the content object shown, not to the latest one."""
param = self.admin.content_pk_url_param
latest = self.createContentInstance("en") # lower pk: picked as latest by .first()
other = self.createContentInstance("en") # higher pk: a different content object
with self.login_user_context(self.admin_user):
post_url, data = self.get_change_form(other)
self.assertIn(f"{param}={other.pk}", post_url)
response = self.client.post(post_url, data=data)
self.assertEqual(response.status_code, 302)
other.refresh_from_db()
latest.refresh_from_db()
self.assertEqual(other.secret_greeting, "Changed content")
self.assertNotEqual(latest.secret_greeting, "Changed content")
def test_save_and_continue_keeps_requested_content_obj(self) -> None:
"""Saving and continuing to edit returns to the very content object that was edited."""
param = self.admin.content_pk_url_param
self.createContentInstance("en")
other = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
post_url, data = self.get_change_form(other)
response = self.client.post(post_url, data={**data, "_continue": "1"})
self.assertEqual(response.status_code, 302)
self.assertIn(f"{param}={other.pk}", response.url)
def test_save_returns_to_changelist_without_content_selection(self) -> None:
"""Plain saving returns to the changelist, which always lists the latest content."""
param = self.admin.content_pk_url_param
self.createContentInstance("en")
other = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
post_url, data = self.get_change_form(other)
response = self.client.post(post_url, data=data)
self.assertEqual(response.status_code, 302)
self.assertNotIn(param, response.url)
def test_changelist_ignores_content_selection(self) -> None:
"""The content selection is no filter: the changelist ignores it instead of rejecting it
as an unknown lookup."""
param = self.admin.content_pk_url_param
content = self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(f"{self.changelist_url}?{param}={content.pk}")
self.assertEqual(response.status_code, 200)
self.assertContains(response, content.secret_greeting)
class GrouperContentSelectionTestCase(SetupMixin, SimpleGrouperContentSelectionTestCase):
"""Same, for a grouper admin that groups by language."""
class GrouperCanChangeContentTestCase(SetupMixin, CMSTestCase):
"""Tests for ``GrouperModelAdmin.can_change_content`` in both the add and change case.
The sampleapp's ``GrouperAdmin`` overrides ``can_change_content``, so we call the base
implementation directly. ``request.user`` is a ``MagicMock`` because Django's default
auth backend returns no object-level permissions for non-superusers, which would make
the change case impossible to exercise otherwise."""
def _can_change_content(self, request, content_obj):
return GrouperModelAdmin.can_change_content(self.admin, request, content_obj)
def _request(self, has_perm_return=True):
request = self.get_request()
request.user = MagicMock()
request.user.has_perm.return_value = has_perm_return
return request
def test_add_case_checks_add_permission(self):
"""Without a content object, the content model's add permission is checked."""
request = self._request(has_perm_return=True)
self.assertTrue(self._can_change_content(request, None))
opts = GrouperModelContent._meta
expected_perm = f"{opts.app_label}.{get_permission_codename('add', opts)}"
request.user.has_perm.assert_called_once_with(expected_perm, None)
def test_add_case_denied_without_permission(self):
"""Without the add permission, the add case returns False."""
request = self._request(has_perm_return=False)
self.assertFalse(self._can_change_content(request, None))
def test_change_case_checks_change_permission(self):
"""With a content object, the change permission is checked, passing the object for
object-level backends."""
content_obj = self.createContentInstance("en")
request = self._request(has_perm_return=True)
self.assertTrue(self._can_change_content(request, content_obj))
opts = GrouperModelContent._meta
expected_perm = f"{opts.app_label}.{get_permission_codename('change', opts)}"
request.user.has_perm.assert_called_once_with(expected_perm, content_obj)
def test_change_case_denied_without_permission(self):
"""Without the change permission, the change case returns False."""
content_obj = self.createContentInstance("en")
request = self._request(has_perm_return=False)
self.assertFalse(self._can_change_content(request, content_obj))
def test_change_case_respects_is_editable(self):
"""When the content object exposes ``is_editable`` returning False, the user cannot
change it even with the permission."""
content_obj = self.createContentInstance("en")
content_obj.is_editable = lambda *_: False
request = self._request(has_perm_return=True)
self.assertFalse(self._can_change_content(request, content_obj))
def test_superuser_can_change_content_in_both_cases(self):
"""Superusers pass the permission check for both add and change cases."""
request = self.get_request()
request.user = self.admin_user
self.assertTrue(self._can_change_content(request, None))
content_obj = self.createContentInstance("en")
self.assertTrue(self._can_change_content(request, content_obj))
class ReasonedBool(int):
"""Test stand-in for a "rich bool" as returned by e.g. djangocms-versioning's
``as_bool``: truthy/falsy via the int value, with the reason exposed by ``str()``."""
def __new__(cls, value, reason=""):
obj = super().__new__(cls, bool(value))
obj.reason = reason
return obj
def __str__(self):
return self.reason
class GrouperReadonlyMessageTestCase(SetupMixin, CMSTestCase):
"""Tests for ``GrouperModelAdmin.get_content_readonly_message``: the permission
case plus both plain-bool and rich-bool returns from ``is_editable``."""
def _message(self, request, content_obj):
return GrouperModelAdmin.get_content_readonly_message(self.admin, request, content_obj)
def _request(self, has_perm_return=True):
request = self.get_request()
request.user = MagicMock()
request.user.has_perm.return_value = has_perm_return
return request
def test_missing_permission_returns_permission_message(self):
"""Without the change permission, the permission message is returned, regardless
of editability."""
content_obj = self.createContentInstance("en")
request = self._request(has_perm_return=False)
self.assertEqual(
self._message(request, content_obj),
"You do not have permission to change this content.",
)
def test_editable_content_returns_none(self):
"""Editable content (with permission) has no read-only message."""
content_obj = self.createContentInstance("en")
content_obj.is_editable = lambda *_: True
request = self._request(has_perm_return=True)
self.assertIsNone(self._message(request, content_obj))
def test_plain_false_returns_generic_message(self):
"""A plain ``False`` from ``is_editable`` carries no reason, so the generic
message is used."""
content_obj = self.createContentInstance("en")
content_obj.is_editable = lambda *_: False
request = self._request(has_perm_return=True)
self.assertEqual(self._message(request, content_obj), " ")
def test_rich_bool_returns_its_reason(self):
"""A falsy rich bool surfaces its own reason via ``str()``."""
content_obj = self.createContentInstance("en")
content_obj.is_editable = lambda *_: ReasonedBool(False, "Version is not a draft")
request = self._request(has_perm_return=True)
self.assertEqual(self._message(request, content_obj), "Version is not a draft")
def test_truthy_rich_bool_returns_none(self):
"""A truthy rich bool means editable, so no message even though it has a str()."""
content_obj = self.createContentInstance("en")
content_obj.is_editable = lambda *_: ReasonedBool(True)
request = self._request(has_perm_return=True)
self.assertIsNone(self._message(request, content_obj))
class GrouperReadonlyContextMixin:
"""The change form has to be told whether the content object is read-only.
``can_change_content_obj`` used to be added to the context only when ``language``
was among the extra grouping fields, so grouper admins without grouping fields
always rendered the read-only note -- even for perfectly editable content."""
readonly_note = "Some fields cannot be changed since they are read-only content."
def test_editable_content_sets_can_change_content_obj(self):
"""Editable content: the flag is set and the read-only note is not rendered."""
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(self.change_url)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context["can_change_content_obj"])
self.assertIsNone(response.context["content_readonly_message"])
self.assertNotContains(response, self.readonly_note)
@wo_content_permission
def test_readonly_content_clears_can_change_content_obj(self):
"""Read-only content: the flag is cleared and the note is rendered."""
self.createContentInstance("en")
with self.login_user_context(self.admin_user):
response = self.client.get(self.change_url)
self.assertEqual(response.status_code, 200)
self.assertFalse(response.context["can_change_content_obj"])
self.assertContains(response, self.readonly_note)
def test_add_view_sets_can_change_content_obj(self):
"""The add view has no content object yet, so content is never read-only there."""
with self.login_user_context(self.admin_user):
response = self.client.get(self.add_url)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context["can_change_content_obj"])
self.assertNotContains(response, self.readonly_note)
class SimpleGrouperReadonlyContextTestCase(GrouperReadonlyContextMixin, SimpleSetupMixin, CMSTestCase):
"""Grouper admin without extra grouping fields."""
class GrouperReadonlyContextTestCase(GrouperReadonlyContextMixin, SetupMixin, CMSTestCase):
"""Grouper admin with ``language`` as an extra grouping field."""
class SimpleGrouperChangeTestCase(SimpleSetupMixin, CMSTestCase):
def test_save_grouper_model(self) -> None:
# Arrange
random_content = self.createContentInstance()
data = {
"category_name": "Changed content",
"content__region": "world",
"content__language": "de",
"content__secret_greeting": random_content.secret_greeting,
}
with self.login_user_context(self.admin_user):
# Act
response = self.client.post(self.change_url, data=data)
# Assert
self.grouper_instance.refresh_from_db()
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertEqual(self.grouper_instance.category_name, data["category_name"])
def test_save_content_model(self) -> None:
# Arrange
self.createContentInstance()
data = {
"category_name": self.grouper_instance.category_name,
"content__region": "world",
"content__language": "de",
"content__secret_greeting": "New greeting",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.change_url, data=data)
content_instance = SimpleGrouperModelContent.objects.first()
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertIsNotNone(content_instance)
self.assertEqual(content_instance.secret_greeting, data["content__secret_greeting"])
def test_create_grouper_model(self) -> None:
# Arrange
data = {
"category_name": "My new category",
"content__region": "world",
"content__language": "de",
"content__secret_greeting": "Some new content",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.add_url, data=data)
grouper_instance = SimpleGrouperModel.objects.filter(category_name=data["category_name"]).first()
content_instance = grouper_instance.simplegroupermodelcontent_set.first() # Get content
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertEqual(SimpleGrouperModel.objects.all().count(), 2)
self.assertIsNotNone(grouper_instance)
self.assertIsNotNone(content_instance) # Should exist
self.assertEqual(content_instance.secret_greeting, data["content__secret_greeting"]) # Has new content
def test_create_content_model(self) -> None:
# Arrange
self.createContentInstance()
data = {
"category_name": self.grouper_instance.category_name,
"content__region": "world",
"content__language": "de",
"content__secret_greeting": "New content",
}
# Act
with self.login_user_context(self.admin_user):
response = self.client.post(self.change_url, data=data)
content_instance = SimpleGrouperModelContent.objects.first() # Get content
# Assert
self.assertEqual(response.status_code, 302) # Expecting redirect
self.assertIsNotNone(content_instance)
self.assertEqual(content_instance.secret_greeting, data["content__secret_greeting"]) # Has new content
class GrouperSearchTestCase(SimpleSetupMixin, CMSTestCase):
"""Test suite for Grouper model search functionality in Django admin."""
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.SEARCH_FIELDS_DEFAULT = ("category_name", "content__secret_greeting")
cls.SEARCH_FIELDS_GROUPER_ONLY = ("category_name",)
cls.SEARCH_FIELDS_STARTSWITH = ("^category_name", "^content__secret_greeting")
cls.SEARCH_FIELDS_EXACT = ("=category_name", "=content__secret_greeting")
def setUp(self) -> None:
super().setUp()
self._setup_test_data()
self._setup_admin_config()
def _setup_test_data(self):
"""Create test instances and content objects."""
self.another_grouper_instance = SimpleGrouperModel.objects.create(category_name="Another_Category")
self.grouper_content_objects = {}
for grouper in [self.grouper_instance, self.another_grouper_instance]:
self.grouper_content_objects[grouper.id] = self.createContentInstance(
language="en", grouper_instance=grouper, secret_greeting=f"{grouper.category_name}_Greeting"
)
def _setup_admin_config(self):
"""Configure admin search fields."""
self.admin.search_fields = self.SEARCH_FIELDS_DEFAULT
def tearDown(self) -> None:
self.another_grouper_instance.delete()
super().tearDown()
def _get_search_url(self, query=""):
"""Helper to construct search URL."""
return f"{self.changelist_url}?q={query}"
def _get_admin_change_url(self, instance):
"""Helper to construct admin change URL."""
return f'href="/en/admin/sampleapp/{self.groupermodel}/{instance.pk}/change/?'
def _assert_instance_in_response(self, response, instance, should_contain=True):
"""Helper to assert instance presence in response."""
assertion_method = self.assertContains if should_contain else self.assertNotContains
assertion_method(response, instance.category_name)
assertion_method(response, self._get_admin_change_url(instance))
def _assert_search_results(self, response, expected_instances):
"""Helper to assert multiple search results."""
all_instances = [self.grouper_instance, self.another_grouper_instance]
for instance in all_instances:
should_contain = instance in expected_instances
self._assert_instance_in_response(response, instance, should_contain)
def _perform_search(self, query, expected_instances):
"""Helper to perform search and assert results."""
with self.login_user_context(self.admin_user):
response = self.client.get(self._get_search_url(query), follow=True)
self._assert_search_results(response, expected_instances)
return response
def _test_expected_result_count(self, query, expected_count):
with self.login_user_context(self.admin_user):
response = self.client.get(self._get_search_url(query), follow=True)
content = response.content.decode()
actual_count = content.count('class="action-checkbox"')
self.assertEqual(
actual_count,
expected_count,
f"Expected {expected_count} results for query '{query}' "
f"with search_fields {self.admin.search_fields}, got {actual_count}",
)
def test_search_with_empty_query_returns_all_results(self):
"""Empty search query should return all grouper instances."""
expected_instances = [self.grouper_instance, self.another_grouper_instance]
self._perform_search("", expected_instances)
def test_search_by_grouper_category_name(self):
"""Search by grouper's category name should return matching instance."""
search_token = self.grouper_instance.category_name
expected_instances = [self.grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_by_content_field(self):
"""Search by content field should return matching instance."""
content_obj = self.grouper_content_objects[self.grouper_instance.id]
search_token = content_obj.secret_greeting[:5]
expected_instances = [self.grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_with_no_matching_results(self):
"""Search with non-existent term should return no results."""
search_token = get_random_string(10)
expected_instances = []
self._perform_search(search_token, expected_instances)
def test_search_returns_multiple_results_by_category(self):
"""Search by common category term should return multiple instances."""
search_token = "Category"
expected_instances = [self.grouper_instance, self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_returns_multiple_results_by_content(self):
"""Search by common content term should return multiple instances."""
search_token = "Greeting"
expected_instances = [self.grouper_instance, self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_without_content_fields_by_category(self):
"""Search should work when content fields are excluded from search_fields."""
self.admin.search_fields = self.SEARCH_FIELDS_GROUPER_ONLY
search_token = "Category"
expected_instances = [self.grouper_instance, self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_without_content_fields_by_content_returns_nothing(self):
"""Search by content should return nothing when content fields excluded."""
self.admin.search_fields = self.SEARCH_FIELDS_GROUPER_ONLY
search_token = "Greeting"
expected_instances = []
self._perform_search(search_token, expected_instances)
def test_startswith_search_by_category(self):
"""Test startswith (^) search modifier on category field."""
self.admin.search_fields = ("^category_name",)
search_token = "Grouper" # Matches "Grouper_Category" but not "Another_Category"
expected_instances = [self.grouper_instance]
self._perform_search(search_token, expected_instances)
def test_exact_search_by_category(self):
"""Test exact match (=) search modifier on category field."""
self.admin.search_fields = ("=category_name",)
search_token = "Another_Category"
expected_instances = [self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_startswith_search_by_content(self):
"""Test startswith (^) search modifier on content field."""
self.admin.search_fields = ("category_name", "^content__secret_greeting")
content_obj = self.grouper_content_objects[self.another_grouper_instance.id]
search_token = content_obj.secret_greeting[:-5] # Partial match from start
expected_instances = [self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_exact_search_by_content(self):
"""Test exact match (=) search modifier on content field."""
self.admin.search_fields = ("category_name", "=content__secret_greeting")
content_obj = self.grouper_content_objects[self.another_grouper_instance.id]
search_token = content_obj.secret_greeting # Exact match
expected_instances = [self.another_grouper_instance]
self._perform_search(search_token, expected_instances)
def test_search_with_multiple_results_and_grouper_query(self):
"""Test search configuration with category_name contains search."""
query = "Category"
self.admin.search_fields = ("category_name",)
self._test_expected_result_count(query, 2)
def test_search_with_startswith_grouper_query(self):
"""Test search configuration with category_name starts with search."""
query = "Grouper"
self.admin.search_fields = ("^category_name",)
self._test_expected_result_count(query, 1)
def test_search_configurations_category_name_exact(self):
"""Test search configuration with category_name exact match search."""
query = "Another_Category"
self.admin.search_fields = ("=category_name",)
self._test_expected_result_count(query, 1)
def test_search_content_secret_greeting_with_multiple_results(self):
"""Test search configuration with content__secret_greeting field search."""
query = "Greeting"
self.admin.search_fields = ("content__secret_greeting",)
self._test_expected_result_count(query, 2)
View git blame Copy permalink