From 2720d4e5d9522b972beb638d28219a221a3e9bb9 Mon Sep 17 00:00:00 2001 From: Andrei Satsevich Date: Sun, 7 Jan 2024 03:27:56 +0300 Subject: [PATCH 1/3] add success messages tests --- wagtail_localize/locales/tests.py | 172 +++++++++++++++++++++--------- 1 file changed, 120 insertions(+), 52 deletions(-) diff --git a/wagtail_localize/locales/tests.py b/wagtail_localize/locales/tests.py index 5dc6a93a..d1a56a6f 100644 --- a/wagtail_localize/locales/tests.py +++ b/wagtail_localize/locales/tests.py @@ -9,38 +9,50 @@ @override_settings(WAGTAIL_CONTENT_LANGUAGES=[("en", "English"), ("fr", "French")]) -class TestLocaleIndexView(TestCase, WagtailTestUtils): +class BaseLocaleTestCase(TestCase, WagtailTestUtils): def setUp(self): + # Set up the test environment self.login() + self.english = Locale.objects.get() + + def execute_request(self, method, view_name, *args, **kwargs): + # Helper method to execute HTTP requests + url = reverse(view_name, args=args) + params = kwargs.get("params", {}) + post_data = kwargs.get("post_data", {}) + + if method == "GET": + return self.client.get(url, params) + elif method == "POST": + return self.client.post(url, post_data) + + def get(self, view_name, params=None, **kwargs): + # Helper method to execute GET requests + url = reverse(view_name, kwargs=params) + return self.client.get(url, **kwargs) - def get(self, params=None): - return self.client.get(reverse("wagtaillocales:index"), params or {}) +class TestLocaleIndexView(BaseLocaleTestCase): def test_simple(self): - response = self.get() + # Test if the index view renders successfully + response = self.execute_request("GET", "wagtaillocales:index") self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/index.html") -@override_settings(WAGTAIL_CONTENT_LANGUAGES=[("en", "English"), ("fr", "French")]) -class TestLocaleCreateView(TestCase, WagtailTestUtils): - def setUp(self): - self.login() - self.english = Locale.objects.get() - - def get(self, params=None): - return self.client.get(reverse("wagtaillocales:add"), params or {}) - +class TestLocaleCreateView(BaseLocaleTestCase): def post(self, post_data=None): + # Helper method for making POST requests to create a locale return self.client.post(reverse("wagtaillocales:add"), post_data or {}) def test_default_language(self): - # we should have loaded with a single locale + # Ensure the default language is set up correctly self.assertEqual(self.english.language_code, "en") self.assertEqual(self.english.get_display_name(), "English") def test_simple(self): - response = self.get() + # Test if the create view renders successfully with correct choices + response = self.client.get(reverse("wagtaillocales:add")) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/create.html") @@ -49,13 +61,14 @@ def test_simple(self): ) def test_create(self): - response = self.post( - { - "language_code": "fr", - "component-wagtail_localize_localesynchronization-enabled": "on", - "component-wagtail_localize_localesynchronization-sync_from": self.english.id, - } - ) + # Test creating a new locale with synchronization + post_data = { + "language_code": "fr", + "component-wagtail_localize_localesynchronization-enabled": "on", + "component-wagtail_localize_localesynchronization-sync_from": self.english.id, + } + + response = self.client.post(reverse("wagtaillocales:add"), post_data) # Should redirect back to index self.assertRedirects(response, reverse("wagtaillocales:index")) @@ -70,7 +83,21 @@ def test_create(self): ).exists() ) + def test_create_view_success_message(self): + # Send a POST request to the create locale view + response = self.post({"language_code": "fr"}) + + # Check that the response status code is a redirect (302) + self.assertEqual(response.status_code, 302) + + # Follow the redirect to the new page + redirected_response = self.client.get(response.url, follow=True) + + # Now, check that the redirected response contains the expected success message + self.assertContains(redirected_response, "Locale 'French' created.") + def test_duplicate_not_allowed(self): + # Test creating a locale with a duplicate language code response = self.post( { "language_code": "en", @@ -89,6 +116,7 @@ def test_duplicate_not_allowed(self): ) def test_language_code_must_be_in_settings(self): + # Test creating a locale with an invalid language code response = self.post( { "language_code": "ja", @@ -107,6 +135,7 @@ def test_language_code_must_be_in_settings(self): ) def test_sync_from_required_when_enabled(self): + # Test creating a locale with synchronization enabled and missing sync_from response = self.post( { "language_code": "fr", @@ -127,6 +156,7 @@ def test_sync_from_required_when_enabled(self): self.assertFalse(Locale.objects.filter(language_code="fr").exists()) def test_sync_from_not_required_when_disabled(self): + # Test creating a locale with synchronization disabled response = self.post( { "language_code": "fr", @@ -145,6 +175,7 @@ def test_sync_from_not_required_when_disabled(self): self.assertFalse(LocaleSynchronization.objects.exists()) def test_sync_from_required_when_component_required(self): + # Test creating a locale with synchronization component required LOCALE_COMPONENTS[0]["required"] = True try: response = self.post( @@ -169,19 +200,9 @@ def test_sync_from_required_when_component_required(self): self.assertFalse(Locale.objects.filter(language_code="fr").exists()) -@override_settings(WAGTAIL_CONTENT_LANGUAGES=[("en", "English"), ("fr", "French")]) -class TestLocaleEditView(TestCase, WagtailTestUtils): - def setUp(self): - self.login() - self.english = Locale.objects.get() - - def get(self, params=None, locale=None): - locale = locale or self.english - return self.client.get( - reverse("wagtaillocales:edit", args=[locale.id]), params or {} - ) - +class TestLocaleEditView(BaseLocaleTestCase): def post(self, post_data=None, locale=None): + # Helper method for making POST requests to edit a locale post_data = post_data or {} locale = locale or self.english post_data.setdefault("language_code", locale.language_code) @@ -190,10 +211,14 @@ def post(self, post_data=None, locale=None): ) def test_simple(self): - response = self.get() + # Test rendering the edit view with simple data + response = self.client.get( + reverse("wagtaillocales:edit", args=[self.english.id]) + ) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/edit.html") + # Check choices in the form, including the current value self.assertEqual( response.context["form"].fields["language_code"].choices, [ @@ -206,13 +231,15 @@ def test_simple(self): ) def test_invalid_language(self): + # Test editing with an invalid language code invalid = Locale.objects.create(language_code="foo") - response = self.get(locale=invalid) + response = self.get(view_name="wagtaillocales:edit", params={"pk": invalid.pk}) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/edit.html") + # Check choices in the form, showing a default if invalid self.assertEqual( response.context["form"].fields["language_code"].choices, [ @@ -225,6 +252,7 @@ def test_invalid_language(self): ) def test_edit(self): + # Test editing a locale with synchronization response = self.post( { "language_code": "fr", @@ -240,7 +268,25 @@ def test_edit(self): self.english.refresh_from_db() self.assertEqual(self.english.language_code, "fr") + def test_edit_view_success_message(self): + # Test displaying a success message after editing a locale + french_locale = Locale.objects.create(language_code="fr") + + response = self.client.post( + reverse("wagtaillocales:edit", args=[french_locale.id]), + {"language_code": "fr"}, # Change this to the actual language code + follow=True, # Follow redirects in the initial response + ) + + # Check that the response status code is 200 (OK) + self.assertEqual(response.status_code, 200) + + # Check that the redirected response contains the expected success message + expected_success_message = "Locale 'French' updated." # Change this based on your expectations + self.assertContains(response, expected_success_message) + def test_edit_duplicate_not_allowed(self): + # Test editing a locale with a duplicate language code french = Locale.objects.create(language_code="fr") response = self.post( @@ -262,6 +308,7 @@ def test_edit_duplicate_not_allowed(self): ) def test_edit_language_code_must_be_in_settings(self): + # Test editing a locale with an invalid language code response = self.post( { "language_code": "ja", @@ -280,6 +327,7 @@ def test_edit_language_code_must_be_in_settings(self): ) def test_sync_from_required_when_enabled(self): + # Test editing a locale with synchronization enabled and missing sync_from response = self.post( { "language_code": "fr", @@ -297,6 +345,7 @@ def test_sync_from_required_when_enabled(self): ) def test_sync_from_not_required_when_disabled(self): + # Test editing a locale with synchronization disabled response = self.post( { "language_code": "fr", @@ -313,6 +362,7 @@ def test_sync_from_not_required_when_disabled(self): self.assertEqual(self.english.language_code, "fr") def test_sync_from_required_when_component_required(self): + # Test editing a locale with synchronization component required LOCALE_COMPONENTS[0]["required"] = True try: response = self.post( @@ -334,6 +384,7 @@ def test_sync_from_required_when_component_required(self): ) def test_sync_from_cannot_be_the_same_as_locale(self): + # Test editing a locale with synchronization where sync_from is the same as the locale response = self.post( { "language_code": "en", @@ -352,42 +403,44 @@ def test_sync_from_cannot_be_the_same_as_locale(self): ) -@override_settings(WAGTAIL_CONTENT_LANGUAGES=[("en", "English"), ("fr", "French")]) -class TestLocaleDeleteView(TestCase, WagtailTestUtils): - def setUp(self): - self.login() - self.english = Locale.objects.get() - - def get(self, params=None, locale=None): - locale = locale or self.english - return self.client.get( - reverse("wagtaillocales:delete", args=[locale.id]), params or {} - ) +class TestLocaleDeleteView(BaseLocaleTestCase): + def follow_redirect(self, response): + # Helper method to follow redirects in the response + return self.client.get(response.url, follow=True) def post(self, post_data=None, locale=None): + # Helper method for making POST requests to delete a locale locale = locale or self.english return self.client.post( reverse("wagtaillocales:delete", args=[locale.id]), post_data or None ) def test_simple(self): - response = self.get() + # Test that the delete view renders the confirmation template + response = self.execute_request("GET", "wagtaillocales:delete", self.english.id) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtailadmin/generic/confirm_delete.html") def test_delete_locale(self): + # Test deleting a locale french = Locale.objects.create(language_code="fr") - response = self.post(locale=french) + response = self.execute_request("POST", "wagtaillocales:delete", french.id) - # Should redirect back to index - self.assertRedirects(response, reverse("wagtaillocales:index")) + # Follow the redirect to the new page + redirected_response = self.follow_redirect(response) + + # Check if the redirected response was successful (HTTP 200 - OK) + self.assertEqual(redirected_response.status_code, 200) # Check that the locale was deleted self.assertFalse(Locale.objects.filter(language_code="fr").exists()) def test_cannot_delete_locales_with_pages(self): - response = self.post() + # Test attempting to delete a locale with associated pages + response = self.execute_request( + "POST", "wagtaillocales:delete", self.english.id + ) self.assertEqual(response.status_code, 200) @@ -401,3 +454,18 @@ def test_cannot_delete_locales_with_pages(self): # Check that the locale was not deleted self.assertTrue(Locale.objects.filter(language_code="en").exists()) + + def test_delete_locale_success_message(self): + # Test success message after deleting a locale + french = Locale.objects.create(language_code="fr") + + response = self.execute_request("POST", "wagtaillocales:delete", french.id) + # Check if the delete request was successful (HTTP 302 - Found) + self.assertEqual(response.status_code, 302) + + # Follow the redirect to the new page + redirected_response = self.follow_redirect(response) + + # Check that the redirected response contains the expected success message + expected_message = "Locale 'French' deleted." + self.assertContains(redirected_response, expected_message) From db4282f4c6a1c18552658336bbb949183532c3ac Mon Sep 17 00:00:00 2001 From: Andrei Satsevich Date: Sun, 7 Jan 2024 14:16:19 +0300 Subject: [PATCH 2/3] add some tests --- wagtail_localize/locales/tests.py | 98 ++++++++++++++++++++++++++++--- 1 file changed, 90 insertions(+), 8 deletions(-) diff --git a/wagtail_localize/locales/tests.py b/wagtail_localize/locales/tests.py index d1a56a6f..73084ede 100644 --- a/wagtail_localize/locales/tests.py +++ b/wagtail_localize/locales/tests.py @@ -1,8 +1,11 @@ from django.contrib.messages import get_messages +from django.db.models.query import QuerySet from django.test import TestCase, override_settings from django.urls import reverse +from django.utils.translation import gettext_lazy from wagtail.models import Locale from wagtail.test.utils import WagtailTestUtils +from wagtail.utils.version import get_main_version from wagtail_localize.locales.components import LOCALE_COMPONENTS from wagtail_localize.models import LocaleSynchronization @@ -39,6 +42,54 @@ def test_simple(self): self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/index.html") + def test_context_variables(self): + response = self.execute_request("GET", "wagtaillocales:index") + self.assertEqual(response.status_code, 200) + + # Check the presence and types of variables in the context + self.assertIn("locales", response.context) + self.assertIsInstance(response.context["locales"], QuerySet) + + self.assertIn("wagtail_version", response.context) + self.assertIsInstance(response.context["wagtail_version"], str) + + def test_queryset_filtering(self): + response = self.execute_request("GET", "wagtaillocales:index") + self.assertEqual(response.status_code, 200) + + # Check that all objects in the context belong to the expected queryset + for locale in response.context["locales"]: + self.assertIn(locale, Locale.all_objects.all()) + + def test_page_title(self): + response = self.execute_request("GET", "wagtaillocales:index") + self.assertEqual(response.status_code, 200) + + # Assume that page_title returns the expected value + expected_page_title = gettext_lazy("Locales") + self.assertEqual(response.context["page_title"], expected_page_title) + + def test_wagtail_version(self): + response = self.execute_request("GET", "wagtaillocales:index") + self.assertEqual(response.status_code, 200) + + # Assume that get_main_version returns the expected value + expected_wagtail_version = get_main_version() + self.assertEqual(response.context["wagtail_version"], expected_wagtail_version) + + def test_get_locale_usage(self): + # Test get_locale_usage function with different scenarios + # For example, test with a locale that has no pages and others + + # Create a unique locale for testing + locale = Locale.all_objects.create(language_code="fr") + self.assertEqual(locale.language_code, "fr") + + # Execute the request and check if the locale is present in the context + response = self.execute_request("GET", "wagtaillocales:index") + self.assertEqual(response.status_code, 200) + self.assertIn(locale, response.context["locales"]) + class TestLocaleCreateView(BaseLocaleTestCase): def post(self, post_data=None): @@ -55,7 +106,6 @@ def test_simple(self): response = self.client.get(reverse("wagtaillocales:add")) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, "wagtaillocales/create.html") - self.assertEqual( response.context["form"].fields["language_code"].choices, [("fr", "French")] ) @@ -83,6 +133,22 @@ def test_create(self): ).exists() ) + def test_required_component_behavior(self): + # Test behavior when a required component is not provided + LOCALE_COMPONENTS[0]["required"] = True + try: + response = self.post({"language_code": "fr"}) + finally: + LOCALE_COMPONENTS[0]["required"] = False + + self.assertEqual(response.status_code, 200) + self.assertIn("component_form", response.context) + self.assertIn("sync_from", response.context["component_form"].errors) + self.assertEqual( + response.context["component_form"].errors["sync_from"], + ["This field is required."], + ) + def test_create_view_success_message(self): # Send a POST request to the create locale view response = self.post({"language_code": "fr"}) @@ -411,9 +477,29 @@ def follow_redirect(self, response): def post(self, post_data=None, locale=None): # Helper method for making POST requests to delete a locale locale = locale or self.english - return self.client.post( - reverse("wagtaillocales:delete", args=[locale.id]), post_data or None - ) + + if post_data is not None: + # Test case: both post_data and locale provided + return self.client.post( + reverse("wagtaillocales:delete", args=[locale.id]), post_data + ) + else: + # Test case: only locale provided + return self.client.post(reverse("wagtaillocales:delete", args=[locale.id])) + + # Additional test cases for the post method + def test_post_with_post_data(self): + # Test making a POST request with both post_data and locale + post_data = {"key": "value"} + response = self.post(post_data=post_data, locale=self.english) + # Add assertions based on the expected behavior + self.assertEqual(response.status_code, 200, "Expected a successful response") + + def test_post_without_post_data(self): + # Test making a POST request with only locale + response = self.post(locale=self.english) + # Add assertions based on the expected behavior + self.assertEqual(response.status_code, 200, "Expected a successful response") def test_simple(self): # Test that the delete view renders the confirmation template @@ -443,16 +529,12 @@ def test_cannot_delete_locales_with_pages(self): ) self.assertEqual(response.status_code, 200) - - # Check error message messages = list(get_messages(response.wsgi_request)) self.assertEqual(messages[0].level_tag, "error") self.assertEqual( messages[0].message, "This locale cannot be deleted because there are pages and/or other objects using it.\n\n\n\n\n", ) - - # Check that the locale was not deleted self.assertTrue(Locale.objects.filter(language_code="en").exists()) def test_delete_locale_success_message(self): From 9690800fd3bcf2ddf01bb10c1705fa1779a5b8d6 Mon Sep 17 00:00:00 2001 From: Andrei Satsevich Date: Fri, 2 Feb 2024 21:21:42 +0300 Subject: [PATCH 3/3] improved structure, clarity, and consistency --- wagtail_localize/locales/tests.py | 132 ++++++++++++++++-------------- 1 file changed, 70 insertions(+), 62 deletions(-) diff --git a/wagtail_localize/locales/tests.py b/wagtail_localize/locales/tests.py index 73084ede..05acdba1 100644 --- a/wagtail_localize/locales/tests.py +++ b/wagtail_localize/locales/tests.py @@ -18,67 +18,74 @@ def setUp(self): self.login() self.english = Locale.objects.get() - def execute_request(self, method, view_name, *args, **kwargs): + def execute_request( + self, method, view_name, *args, params=None, post_data=None, **kwargs + ): # Helper method to execute HTTP requests url = reverse(view_name, args=args) - params = kwargs.get("params", {}) - post_data = kwargs.get("post_data", {}) + params = params or {} + post_data = post_data or {} if method == "GET": - return self.client.get(url, params) + return self.client.get(url, params, **kwargs) elif method == "POST": - return self.client.post(url, post_data) + return self.client.post(url, post_data, **kwargs) + + def assert_successful_response(self, response): + # Helper method to assert a successful response (status code 200) + self.assertEqual(response.status_code, 200) - def get(self, view_name, params=None, **kwargs): - # Helper method to execute GET requests - url = reverse(view_name, kwargs=params) - return self.client.get(url, **kwargs) + def assert_context_variables(self, response, variable_name, variable_type): + # Helper method to assert the presence and type of context variables + self.assertIn(variable_name, response.context) + self.assertIsInstance(response.context[variable_name], variable_type) + + def assert_redirect_to_index(self, response): + # Helper method to assert redirection to the index page + self.assertRedirects(response, reverse("wagtaillocales:index")) class TestLocaleIndexView(BaseLocaleTestCase): def test_simple(self): # Test if the index view renders successfully response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertTemplateUsed(response, "wagtaillocales/index.html") def test_context_variables(self): + # Test if the context variables are present and have the expected types response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) - - # Check the presence and types of variables in the context - self.assertIn("locales", response.context) - self.assertIsInstance(response.context["locales"], QuerySet) - - self.assertIn("wagtail_version", response.context) - self.assertIsInstance(response.context["wagtail_version"], str) + self.assert_successful_response(response) + self.assert_context_variables(response, "locales", QuerySet) + self.assert_context_variables(response, "wagtail_version", str) def test_queryset_filtering(self): + # Test if the queryset is filtered as expected response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) - - # Check that all objects in the context belong to the expected queryset - for locale in response.context["locales"]: - self.assertIn(locale, Locale.all_objects.all()) + self.assert_successful_response(response) + self.assertTrue( + all( + locale in Locale.all_objects.all() + for locale in response.context["locales"] + ) + ) def test_page_title(self): + # Test if the page title is set correctly response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) - - # Assume that page_title returns the expected value + self.assert_successful_response(response) expected_page_title = gettext_lazy("Locales") self.assertEqual(response.context["page_title"], expected_page_title) def test_wagtail_version(self): + # Test if the Wagtail version is set correctly response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) - - # Assume that get_main_version returns the expected value + self.assert_successful_response(response) expected_wagtail_version = get_main_version() self.assertEqual(response.context["wagtail_version"], expected_wagtail_version) def test_get_locale_usage(self): - # Test get_locale_usage function with different scenarios + # Test the get_locale_usage function with different scenarios # For example, test with a locale that has no pages and others # Create a unique locale for testing @@ -87,7 +94,7 @@ def test_get_locale_usage(self): # Execute the request and check if the locale is present in the context response = self.execute_request("GET", "wagtaillocales:index") - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertIn(locale, response.context["locales"]) @@ -104,7 +111,7 @@ def test_default_language(self): def test_simple(self): # Test if the create view renders successfully with correct choices response = self.client.get(reverse("wagtaillocales:add")) - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertTemplateUsed(response, "wagtaillocales/create.html") self.assertEqual( response.context["form"].fields["language_code"].choices, [("fr", "French")] @@ -118,9 +125,10 @@ def test_create(self): "component-wagtail_localize_localesynchronization-sync_from": self.english.id, } - response = self.client.post(reverse("wagtaillocales:add"), post_data) + response = self.post(post_data) # Should redirect back to index + self.assert_redirect_to_index(response) self.assertRedirects(response, reverse("wagtaillocales:index")) # Check that the locale was created @@ -141,7 +149,7 @@ def test_required_component_behavior(self): finally: LOCALE_COMPONENTS[0]["required"] = False - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertIn("component_form", response.context) self.assertIn("sync_from", response.context["component_form"].errors) self.assertEqual( @@ -173,7 +181,7 @@ def test_duplicate_not_allowed(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) form = response.context["form"] self.assertIn("language_code", form.errors) self.assertEqual( @@ -192,7 +200,7 @@ def test_language_code_must_be_in_settings(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) form = response.context["form"] self.assertIn("language_code", form.errors) self.assertEqual( @@ -211,7 +219,7 @@ def test_sync_from_required_when_enabled(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) component_form = response.context["component_form"] self.assertIn("sync_from", component_form.errors) self.assertEqual( @@ -255,7 +263,7 @@ def test_sync_from_required_when_component_required(self): LOCALE_COMPONENTS[0]["required"] = False # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) component_form = response.context["component_form"] self.assertIn("sync_from", component_form.errors) self.assertEqual( @@ -281,7 +289,7 @@ def test_simple(self): response = self.client.get( reverse("wagtaillocales:edit", args=[self.english.id]) ) - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertTemplateUsed(response, "wagtaillocales/edit.html") # Check choices in the form, including the current value @@ -300,10 +308,10 @@ def test_invalid_language(self): # Test editing with an invalid language code invalid = Locale.objects.create(language_code="foo") - response = self.get(view_name="wagtaillocales:edit", params={"pk": invalid.pk}) - - self.assertEqual(response.status_code, 200) - self.assertTemplateUsed(response, "wagtaillocales/edit.html") + response = self.client.get( + reverse("wagtaillocales:edit", kwargs={"pk": invalid.pk}) + ) + self.assert_successful_response(response) # Check choices in the form, showing a default if invalid self.assertEqual( @@ -328,6 +336,7 @@ def test_edit(self): ) # Should redirect back to index + self.assert_redirect_to_index(response) self.assertRedirects(response, reverse("wagtaillocales:index")) # Check that the locale was edited @@ -345,7 +354,7 @@ def test_edit_view_success_message(self): ) # Check that the response status code is 200 (OK) - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) # Check that the redirected response contains the expected success message expected_success_message = "Locale 'French' updated." # Change this based on your expectations @@ -365,7 +374,7 @@ def test_edit_duplicate_not_allowed(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) form = response.context["form"] self.assertIn("language_code", form.errors) self.assertEqual( @@ -384,7 +393,7 @@ def test_edit_language_code_must_be_in_settings(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) form = response.context["form"] self.assertIn("language_code", form.errors) self.assertEqual( @@ -403,7 +412,7 @@ def test_sync_from_required_when_enabled(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) component_form = response.context["component_form"] self.assertIn("sync_from", component_form.errors) self.assertEqual( @@ -421,7 +430,7 @@ def test_sync_from_not_required_when_disabled(self): ) # Should redirect back to index - self.assertRedirects(response, reverse("wagtaillocales:index")) + self.assert_redirect_to_index(response) # Check that the locale was edited self.english.refresh_from_db() @@ -442,7 +451,7 @@ def test_sync_from_required_when_component_required(self): LOCALE_COMPONENTS[0]["required"] = False # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) component_form = response.context["component_form"] self.assertIn("sync_from", component_form.errors) self.assertEqual( @@ -460,7 +469,7 @@ def test_sync_from_cannot_be_the_same_as_locale(self): ) # Should return the form with errors - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) component_form = response.context["component_form"] self.assertIn("sync_from", component_form.errors) self.assertEqual( @@ -493,18 +502,18 @@ def test_post_with_post_data(self): post_data = {"key": "value"} response = self.post(post_data=post_data, locale=self.english) # Add assertions based on the expected behavior - self.assertEqual(response.status_code, 200, "Expected a successful response") + self.assert_successful_response(response) def test_post_without_post_data(self): # Test making a POST request with only locale response = self.post(locale=self.english) # Add assertions based on the expected behavior - self.assertEqual(response.status_code, 200, "Expected a successful response") + self.assert_successful_response(response) def test_simple(self): # Test that the delete view renders the confirmation template response = self.execute_request("GET", "wagtaillocales:delete", self.english.id) - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) self.assertTemplateUsed(response, "wagtailadmin/generic/confirm_delete.html") def test_delete_locale(self): @@ -512,15 +521,14 @@ def test_delete_locale(self): french = Locale.objects.create(language_code="fr") response = self.execute_request("POST", "wagtaillocales:delete", french.id) - - # Follow the redirect to the new page redirected_response = self.follow_redirect(response) - # Check if the redirected response was successful (HTTP 200 - OK) - self.assertEqual(redirected_response.status_code, 200) + # Check if the redirected response was successful (HTTP 302 - Found) + self.assert_successful_response(redirected_response) # Check that the locale was deleted self.assertFalse(Locale.objects.filter(language_code="fr").exists()) + self.assertRedirects(response, reverse("wagtaillocales:index")) def test_cannot_delete_locales_with_pages(self): # Test attempting to delete a locale with associated pages @@ -528,7 +536,8 @@ def test_cannot_delete_locales_with_pages(self): "POST", "wagtaillocales:delete", self.english.id ) - self.assertEqual(response.status_code, 200) + self.assert_successful_response(response) + messages = list(get_messages(response.wsgi_request)) self.assertEqual(messages[0].level_tag, "error") self.assertEqual( @@ -542,12 +551,11 @@ def test_delete_locale_success_message(self): french = Locale.objects.create(language_code="fr") response = self.execute_request("POST", "wagtaillocales:delete", french.id) - # Check if the delete request was successful (HTTP 302 - Found) - self.assertEqual(response.status_code, 302) - - # Follow the redirect to the new page redirected_response = self.follow_redirect(response) + # Check if the delete request was successful (HTTP 302 - Found) + self.assert_successful_response(redirected_response) + # Check that the redirected response contains the expected success message expected_message = "Locale 'French' deleted." self.assertContains(redirected_response, expected_message)