df_site 0.1.0__py3-none-any.whl

df_site/testing/multiple_views.py

@@ -0,0 +1,369 @@
+"""A generic class testing several views with different users.
+
+The expected response can by defined by the response code, a HttpResponse, an exception or a callable.
+In these case, a RequestTester will be built with this value as first argument.
+Otherwise, you can also provide a RequestTester (especially to provide GET or POST arguments).
+"""
+
+import logging
+from typing import Dict, List, Optional, Tuple, Type, TypeAlias, Union
+from urllib.parse import urlencode
+
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.admin.sites import site as default_site
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import AbstractUser, AnonymousUser
+from django.contrib.messages.middleware import MessageMiddleware
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.core.exceptions import PermissionDenied
+from django.db import models
+from django.http import Http404, HttpResponse, SimpleCookie
+from django.middleware.csrf import get_token
+from django.test import RequestFactory, TestCase
+from django.urls import URLPattern
+from django.urls.resolvers import RoutePattern
+from django.utils.encoding import iri_to_uri
+
+from df_site.testing.requests import RequestTester
+
+logger = logging.getLogger(__name__)
+ExpectedResponse: TypeAlias = Union[int, Exception, Type[Exception], HttpResponse, callable, RequestTester]
+ExpectedResponses = Union[List[ExpectedResponse], ExpectedResponse]
+
+
+class TestMultipleViews(TestCase):
+    """Define some methods for testing a set of views with different users (identified by its username).
+
+    `expected_responses` is a dict such that:
+    - the key is the view name
+    - the value is a dict such that:
+        - the key is a USER_KEY (can be anything, like its privilege level)
+        - the value is any of:
+            - an integer (the expected HTTP status code — then this is the only checked thing)
+            - an exception (only the type of the raised exception is checked)
+            - a HttpResponse (only status_codes are checked)
+            - a callable that will be given the TestCase and the HttpResponse as arguments
+            - a RequestTester to deeply customize the test (including the request args/kwargs)
+            - a list of any of the previous values
+
+    You must override `get_user_keys` to provide a list of values to create different users.
+        (`str(value)` is used to get the username)
+    Your test_* methods must call
+        check_url_patterns(url_patterns, common_kwargs, expected_responses, display_prefix=display_prefix)
+    """
+
+    views_test_counter = 0
+    call_test_counter = 0
+
+    @classmethod
+    def setUpClass(cls):
+        """Create some users and a request factory for testing."""
+        super().setUpClass()
+        # Every test needs access to the request factory.
+        cls.request_factory = RequestFactory()
+        cls.created_users: List[AbstractUser] = cls.create_users()
+
+    def setUp(self):
+        """Counts the number of run tests."""
+        TestMultipleViews.call_test_counter += 1
+        return super().setUp()
+
+    @classmethod
+    def get_users(cls) -> List[AbstractUser]:
+        """Teturn a list of values to identify different users.
+
+        The special value `None` is dedicated to AnonymousUser.
+        """
+        return cls.created_users
+
+    @classmethod
+    def create_users(cls):
+        """Create some users for testing."""
+        return [
+            AnonymousUser(),
+            cls.create_user("staff", is_staff=True),
+            cls.create_user("admin", is_staff=True, is_superuser=True),
+        ]
+
+    @classmethod
+    def create_user(cls, name, is_active=True, **kwargs):
+        """Create a user with the provided name."""
+        user = get_user_model().objects.filter(username=name).first()
+        if user is not None:
+            return user
+        user_kwargs = {
+            "email": f"{name}@test.com",
+            "is_active": is_active,
+        }
+        user_kwargs.update(kwargs)
+        return get_user_model().objects.create_user(username=name, **user_kwargs)
+
+    def create_request(
+        self,
+        url,
+        *args,
+        method=None,
+        user=None,
+        form_data=None,
+        get_data=None,
+        post_data=None,
+        **kwargs,
+    ):
+        """Return a request object for the provided URL."""
+        if form_data:
+            kwargs["data"] = urlencode(form_data)
+            kwargs["content_type"] = "application/x-www-form-urlencoded"
+        if method:
+            method = method.lower()
+        if method and method in ("get", "head") and get_data:
+            kwargs["data"] = get_data
+        elif get_data:
+            kwargs["QUERY_STRING"] = urlencode(get_data, doseq=True)
+        if post_data:
+            kwargs["data"] = post_data
+            method = method or "post"
+            request = self.request_factory.generic(method.upper(), url, *args, **kwargs)
+        else:
+            method = method or "get"
+            request = getattr(self.request_factory, method)(url, *args, **kwargs)
+        request.user = user or AnonymousUser()
+        request.cookies = SimpleCookie()
+        setattr(request, "_dont_enforce_csrf_checks", True)
+        request.cookies["csrftoken"] = get_token(request)
+
+        def get_response():
+            pass
+
+        SessionMiddleware(get_response).process_request(request)
+        MessageMiddleware(get_response).process_request(request)
+        return request
+
+    def check_url_patterns(
+        self,
+        url_patterns: List[Tuple[str, URLPattern]],
+        common_kwargs: Dict[str, str],
+        expected_responses: Dict[str, Dict[Optional[str], ExpectedResponses]],
+        display_prefix: str = "",
+    ):
+        """Check all provided URL patterns.
+
+        :param url_patterns: list of ("namespace:", URLPattern)  (leave "" if no namespace)
+        :param common_kwargs: kwargs common to all URL patterns
+            (use `expected_responses` to provided kwargs specific to a URL pattern)
+        :param expected_responses:
+        :param display_prefix: prefix added to displayed error messages
+        :return:
+        """
+        failures = []  # list of (url_pattern, ps, exception)
+        for namespace, url_pattern in url_patterns:
+            if url_pattern.name:
+                view_name = f"{namespace}{url_pattern.name}"
+            else:
+                view_name = None
+            url_name = self.format_url_pattern(url_pattern)
+            view = url_pattern.callback
+            provided_view_kwargs = url_pattern.default_args
+            # "kwargs" argument provided to path()
+            if isinstance(url_pattern.pattern, RoutePattern):
+                arg_names = list(url_pattern.pattern.converters.keys())
+            else:
+                arg_names = list(url_pattern.pattern.regex.groupindex)
+            reverse_kwargs = {k: common_kwargs[k] for k in arg_names if k in common_kwargs}
+            for user in self.get_users():
+                username = None if user.is_anonymous else user.username
+                request_testers_: ExpectedResponses = expected_responses.get(url_name, {}).get(username, Http404)
+                if not isinstance(request_testers_, list):
+                    request_testers: List[ExpectedResponse] = [request_testers_]
+                else:
+                    request_testers: List[ExpectedResponse] = request_testers_
+                for request_tester in request_testers:
+                    if not isinstance(request_tester, RequestTester):
+                        request_tester = RequestTester(request_tester)
+                    # actual view kwargs are the kwargs provided in the get_urls()
+                    self.__class__.views_test_counter += 1
+                    exc = request_tester.evaluate(
+                        self,
+                        view_name,
+                        view,
+                        reverse_kwargs,
+                        provided_view_kwargs,
+                        user,
+                    )
+                    if exc is not None:
+                        failed_url = request_tester.request.path + (
+                            "?" + iri_to_uri(request_tester.request.META.get("QUERY_STRING", ""))
+                            if request_tester.request.META.get("QUERY_STRING", "")
+                            else ""
+                        )
+                        failure = (
+                            url_pattern,
+                            username,
+                            exc,
+                            failed_url,
+                        )
+                        failures.append(failure)
+        for url_pattern, username, e, url in failures:
+            pattern = self.format_url_pattern(url_pattern)
+            if username is None:
+                username = "AnonymousUser"
+            else:
+                username = f"user {username}"
+            base_url = settings.SERVER_BASE_URL[:-1]
+            msg = f"{display_prefix}Exception in {pattern} with {username}: {e} ({base_url}{url})."
+            print(msg)
+        self.assertEqual(0, len(failures))
+
+    @staticmethod
+    def format_url_pattern(url_pattern) -> str:
+        """Return a string representation of the provided URL pattern."""
+        if url_pattern.name:
+            return url_pattern.name
+        if isinstance(url_pattern.pattern, RoutePattern):
+            return url_pattern.pattern._route
+        return url_pattern.pattern._regex
+
+
+class TestModelAdmin(TestMultipleViews):
+    """Define some methods for testing *all* views defined in the get_urls() of a ModelAdmin.
+
+     Each view is tested with different users.
+    . A RequestTester define more precisely how to test a given view with a given user.
+
+    Many of these views require some kwargs for the `reverse` function, but most of them have always the same meaning.
+    So, we always reuse the same kwargs for all views (but we can override them in a RequestTester).
+
+    `expected_responses` is a dict such that:
+    - the key is the view name
+    - the value is a dict such that:
+        - the key is a username (or None for AnonymousUser)
+        - the value is any of:
+            - an integer (the expected HTTP status code — then this is the only checked thing)
+            - an exception (only the type of the raised exception is checked)
+            - a HttpResponse (only status_codes are checked)
+            - a callable that will be given the TestCase and the HttpResponse as arguments
+            - a RequestTester to deeply customize the test (including the request args/kwargs)
+            - a list of any of the previous values
+
+    """
+
+    checked_model_admins = set()
+    placeholders = "%(app_label)s_%(model_name)s_"
+    expected_responses: Dict[str, Dict[Optional[str], ExpectedResponses]] = {
+        f"{placeholders}changelist": {
+            None: 302,
+            "staff": PermissionDenied,
+            "admin": 200,
+        },
+        f"{placeholders}add": {
+            None: 302,
+            "staff": PermissionDenied,
+            "admin": 200,
+        },
+        f"{placeholders}history": {
+            None: 302,
+            "staff": PermissionDenied,
+            "admin": 200,
+        },
+        f"{placeholders}delete": {
+            None: 302,
+            "staff": PermissionDenied,
+            "admin": 200,
+        },
+        f"{placeholders}change": {
+            None: 302,
+            "staff": PermissionDenied,
+            "admin": 200,
+        },
+        "<path:object_id>/": {
+            None: 302,
+            "staff": 302,
+            "admin": 302,
+        },
+    }
+
+    # expected_responses["view_name"]["staff"] = 200
+    # %(app_label)s and %(model_name)s can
+    # be used in the view names to avoid repeating the same values.
+    def check_model_admin(
+        self,
+        model_admin: Union[Type[admin.ModelAdmin], Type[models.Model]],
+        common_kwargs: Dict[str, str],
+        display_prefix: str = "",
+        expected_responses: Dict[str, Dict[Optional[str], ExpectedResponses]] = None,
+    ):
+        """Check all admin views.
+
+        :param model_admin: the models.Model or admin.ModelAdmin to check
+        :param common_kwargs: dict of values for reversing URLs
+        :param display_prefix: prefix to display in front of each error
+        :param expected_responses: extra responses, only for this ModelAdmin
+            (same format as self.expected_responses)
+        :return:
+        """
+        if isinstance(model_admin, type) and issubclass(model_admin, models.Model):
+            model_admin = default_site.get_model_admin(model_admin)
+
+        TestModelAdmin.checked_model_admins.add(model_admin)
+        base_expected_responses = self.get_expected_responses(model_admin, raw_expected_responses=expected_responses)
+        # with app_label="app", model_name="model", if we have both
+        #   "%(app_label)s_%(model_name)s_viewname" and "app_model_viewname" keys  in raw_expected_responses
+        #   we do not want to override the initial values.
+        url_patterns = self.get_admin_urls(model_admin)
+        self.check_url_patterns(
+            url_patterns,
+            common_kwargs,
+            base_expected_responses,
+            display_prefix=display_prefix,
+        )
+
+    def get_expected_responses(
+        self,
+        model_admin: admin.ModelAdmin,
+        raw_expected_responses: Dict[str, Dict[Optional[str], ExpectedResponses]] = None,
+    ) -> Dict[str, Dict[Optional[str], ExpectedResponses]]:
+        """Return the expected responses for this model_admin.
+
+        Replace %(app_label)s and %(model_name)s placeholders in the view names and use
+        them when these view names are missing from the expected_responses.
+        """
+        base_expected_responses = {}
+        base_expected_responses.update(self.expected_responses)
+        if raw_expected_responses is not None:
+            base_expected_responses.update(raw_expected_responses)
+
+        opts = {
+            "app_label": model_admin.model._meta.app_label,
+            "model_name": model_admin.model._meta.model_name,
+        }
+        expected_responses = {url_name % opts: v for (url_name, v) in base_expected_responses.items() if url_name}
+        expected_responses.update(base_expected_responses)
+        return expected_responses
+
+    # noinspection PyMethodMayBeStatic
+    def get_admin_urls(self, model_admin: admin.ModelAdmin) -> List[Tuple[str, URLPattern]]:
+        """Return the list of all URLs in this model_admin."""
+        return [("admin:", x) for x in model_admin.get_urls()]
+
+
+class TestModel(TestModelAdmin):
+    """Define some methods for testing all views defined in the get_urls() of a ModelAdmin."""
+
+    def get_object(self):
+        """Return an object of the model to test."""
+        raise NotImplementedError("You must override this method to return an object of the model to test.")
+
+    def test_model_admin(self):
+        """Test all views of the model admin correspoding to the provided object."""
+        try:
+            obj = self.get_object()
+        except NotImplementedError as e:
+            self.skipTest(str(e))
+        if obj._state.adding:
+            obj.save()
+        common_kwargs = self.get_common_kwargs_for_object(obj)
+        self.check_model_admin(obj.__class__, common_kwargs=common_kwargs, display_prefix="")
+
+    def get_common_kwargs_for_object(self, obj) -> Dict[str, str]:
+        """Return the common kwargs for all views of the provided object."""
+        return {"object_id": str(obj.pk)}

df_site/testing/requests.py

@@ -0,0 +1,299 @@
+"""Check if a response from a Django view meets the expectations.
+
+These expectations can be as low as a simple HTTP code.
+"""
+
+import json
+import traceback
+from html.parser import HTMLParser
+from typing import Callable, Dict, List, Optional, Set, Tuple, Type, Union
+from unittest import TestCase
+
+from django.contrib.auth.models import AbstractUser
+from django.core.exceptions import PermissionDenied
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.http import Http404, HttpRequest, HttpResponse, JsonResponse
+from django.template.response import TemplateResponse
+from django.urls import reverse
+
+
+class FormHTMLParser(HTMLParser):
+    """Fetch all field names in a HTML document."""
+
+    def __init__(
+        self,
+        form_id: Optional[str] = None,
+        convert_charrefs=True,
+        ignored_fields: Optional[Set[str]] = None,
+        ignored_types: Optional[Set[str]] = None,
+    ):
+        """Initialize the parser."""
+        super().__init__(convert_charrefs=convert_charrefs)
+        self.form_id = form_id
+        self.form_fields: Set[str] = set()
+        self.is_in_selected_form = False
+        if ignored_fields is None:
+            ignored_fields = {"csrfmiddlewaretoken"}
+        if ignored_types is None:
+            ignored_types = {"submit", "reset", "button", "image"}
+        self.ignored_fields = ignored_fields
+        self.ignored_types = ignored_types
+
+    def reset(self, form_id=None):
+        """Reset the parser."""
+        super().reset()
+        self.form_fields: Set[str] = set()
+        self.is_in_selected_form = False
+
+    def handle_starttag(self, tag: str, attrs: List[Tuple[str, str]]):
+        """Check if we are in the form and if we look at a field."""
+        attrs = dict(attrs)
+        if tag == "form" and (self.form_id is None or attrs.get("id") == self.form_id):
+            self.is_in_selected_form = True
+        if self.is_in_selected_form and tag in {"input", "select", "textarea"} and "name" in attrs:
+            if attrs["name"] in self.ignored_fields:
+                return
+            elif tag == "input" and attrs.get("type") in self.ignored_types:
+                return
+            self.form_fields.add(attrs["name"])
+
+    def handle_endtag(self, tag):
+        """Check if we are still in the form."""
+        if tag == "form":
+            self.is_in_selected_form = False
+
+    def error(self, message):
+        """Does nothing when there is an error."""
+        pass
+
+
+class RequestTester:
+    """Check if the response of a Django view meets the expectation."""
+
+    def __init__(
+        self,
+        expected_response: Union[int, Exception, Type[Exception], HttpResponse, callable] = 200,
+        method="get",
+        form_data: Union[Dict[str, str], Callable] = None,
+        get_data: Union[Dict[str, str], Callable] = None,
+        post_data: Union[bytes, Dict[str, str], Callable] = None,
+        files_data: Dict[str, SimpleUploadedFile] = None,
+        raise_error: bool = False,
+        reverse_kwargs: Union[Dict, Callable] = None,
+        request_kwargs: Dict = None,
+        view_kwargs: Union[Dict, Callable] = None,
+        validators=None,
+        headers: Optional[Dict[str, str]] = None,
+        **response_attr,
+    ):
+        """Initialize the object."""
+        self.method = method.lower()
+        self.form_data = form_data
+        self.headers = headers or {}
+        self.post_data = post_data
+        self.files_data = files_data or {}
+        self.expected_response = expected_response
+        self.raise_error = raise_error
+        self.request_kwargs = request_kwargs or {}  # extra kwargs for building the HttpRequest
+        self.reverse_kwargs = (
+            reverse_kwargs or {}
+        )  # extra kwargs provided to the callable and to the `reverse` function
+        self.view_kwargs = view_kwargs or {}  # extra kwargs provided to the callabble
+        self.get_data = get_data or {}  # provide the GET QueryDict of the created HttpRequest
+        self.validators = validators or []  # list of callable(testCase, HttpResponse)
+        self.response_attr = response_attr  # extra response attrs
+        self.request = None
+
+    @staticmethod
+    def callable_value(value, test_case: TestCase, complete_url_name: str, user: AbstractUser):
+        """Call the callable if possible, otherwise return the value."""
+        if callable(value):
+            return value(test_case, complete_url_name, user)
+        return value
+
+    # noinspection PyUnusedLocal
+    def get_request_kwargs(self, test_case: TestCase, complete_url_name: str, user: AbstractUser) -> Dict:
+        """Build all kwargs provided to the request factory."""
+        merged_request_kwargs = {}
+        merged_request_kwargs.update(self.request_kwargs)
+        if self.form_data:
+            merged_request_kwargs["form_data"] = self.callable_value(self.form_data, test_case, complete_url_name, user)
+        if self.get_data:
+            merged_request_kwargs["get_data"] = self.callable_value(self.get_data, test_case, complete_url_name, user)
+        if self.post_data:
+            merged_request_kwargs["post_data"] = self.callable_value(self.post_data, test_case, complete_url_name, user)
+        if self.headers:
+            merged_request_kwargs["headers"] = self.headers
+        return merged_request_kwargs
+
+    def get_request_method(self, test_case: TestCase, complete_url_name: str, user: AbstractUser) -> str:
+        """Return the HTTP method."""
+        return self.callable_value(self.method, test_case, complete_url_name, user)
+
+    def get_view_kwargs(self, test_case: TestCase, complete_url_name: str, user: AbstractUser) -> Dict:
+        """Return extra kwargs provided to the view."""
+        return self.callable_value(self.view_kwargs, test_case, complete_url_name, user)
+
+    def get_reverse_kwargs(self, test_case: TestCase, complete_url_name: str, user: AbstractUser) -> Dict:
+        """Return the kwargs used for reversing the URL."""
+        return self.callable_value(self.reverse_kwargs, test_case, complete_url_name, user)
+
+    def get_http_request(self, test_case, view_name: str, reverse_kwargs: Dict, user: AbstractUser) -> HttpRequest:
+        """Return the HttpRequest."""
+        if view_name:
+            url = reverse(view_name, kwargs=reverse_kwargs)
+        else:
+            url = "/unnamed/view"
+        method = self.get_request_method(test_case, view_name, user)
+        request_kwargs = self.get_request_kwargs(test_case, view_name, user)
+        request = test_case.create_request(url, method=method, **request_kwargs)
+        if self.files_data:
+            request.FILES.update(self.files_data)
+        request.user = user
+        return request
+
+    def evaluate(
+        self,
+        test_case,
+        view_name: str,
+        view: callable,
+        reverse_kwargs: Dict,
+        view_kwargs: Dict,
+        user: AbstractUser,
+    ) -> Optional[Exception]:
+        """Evaluate a single view with the provided reverse kwargs and view kwargs.
+
+        :param test_case: the test case evaluating this function (maybe some attributes are required)
+        :param view_name: the name of the tested view
+        :param view: the tested view itself
+        :param reverse_kwargs: kwargs used for the `reverse` function (updated by `get_reverse_kwargs`)
+        :param view_kwargs: extra args passed to the view (updated by `get_view_kwargs`)
+        :param user: the tested permission set
+        """
+        merged_reverse_kwargs = {}
+        merged_reverse_kwargs.update(reverse_kwargs)
+        merged_reverse_kwargs.update(self.get_reverse_kwargs(test_case, view_name, user))
+
+        request = self.get_http_request(test_case, view_name, merged_reverse_kwargs, user)
+        self.request = request
+
+        merged_view_kwargs = merged_reverse_kwargs
+        merged_view_kwargs.update(view_kwargs)
+        merged_view_kwargs.update(self.get_view_kwargs(test_case, view_name, user))
+        if self.raise_error:
+            self.check_response(test_case, request, view, merged_view_kwargs, user)
+        else:
+            try:
+                self.check_response(test_case, request, view, merged_view_kwargs, user)
+            except Exception as e:
+                if not isinstance(e, PermissionDenied) and not isinstance(e, Http404):
+                    traceback.print_exc()
+                return e
+
+    def check_response(
+        self,
+        test_case: TestCase,
+        request: HttpRequest,
+        view: callable,
+        view_kwargs: Dict,
+        user: AbstractUser,
+    ):
+        """Check if the response meets the expectation."""
+        expected_response = self.expected_response
+        # noinspection PyUnusedLocal
+        user = user
+        if isinstance(expected_response, type) and issubclass(expected_response, Exception):
+            test_case.assertRaises(expected_response, lambda: view(request, **view_kwargs))
+            return
+        http_response = view(request, **view_kwargs)
+        if isinstance(http_response, TemplateResponse):
+            http_response.render()
+        for validator in self.validators:
+            validator(test_case, http_response)
+        if isinstance(expected_response, int):
+            if expected_response != http_response.status_code:
+                # do not use test_case.assertEqual to have a more explicit error
+                msg = f"HTTP {http_response.status_code} (while expecting {expected_response})"
+                msg += self.get_description(request)
+                raise AssertionError(msg)
+        elif isinstance(expected_response, HttpResponse):
+            if expected_response.status_code != http_response.status_code:
+                # do not use test_case.assertEqual to have a more explicit error
+                msg = f"HTTP {http_response.status_code} (while expecting {expected_response.status_code})"
+                msg += self.get_description(request)
+                raise AssertionError(msg)
+            test_case.assertIsInstance(http_response, expected_response.__class__)
+        elif callable(expected_response):
+            expected_response(test_case, http_response)
+        else:
+            raise ValueError(f"unknown type of expected response: {expected_response!r}")
+        for attr_name, attr_value in self.response_attr.items():
+            if isinstance(attr_value, type):
+                test_case.assertIsInstance(attr_value, getattr(http_response, attr_name))
+            else:
+                test_case.assertEqual(attr_value, getattr(http_response, attr_name))
+
+    def get_description(self, request: HttpRequest) -> str:
+        """Return a string representation of a RequestTester."""
+        msg = f" url = {request.path}"
+        if self.method != "get":
+            msg += f" method={self.method}"
+        if self.headers:
+            msg += f" headers={self.headers}"
+        if self.post_data:
+            post_data = str(self.post_data)[:30]
+            msg += f" post_data={post_data}"
+        if self.form_data or self.get_data:
+            post_data = str(self.form_data)[:30]
+            msg += f" form_data={post_data}"
+        if self.get_data:
+            post_data = str(self.get_data)[:30]
+            msg += f" get_data={post_data}"
+        return msg
+
+
+class HTMLFormRequestTester(RequestTester):
+    """Validate a form in the HTML response, for example to check if required fields are present."""
+
+    def __init__(
+        self,
+        required_fields: Set[str],
+        *args,
+        form_id: Optional[str] = None,
+        ignored_fields: Optional[Set[str]] = None,
+        ignored_types: Optional[Set[str]] = None,
+        **kwargs,
+    ):
+        """Initialize the object with expected values."""
+        self.required_fields = required_fields
+        kwargs.setdefault("validators", [])
+        kwargs["validators"].append(self.check_required_fields)
+        self.form_id = form_id
+        self.ignored_fields = ignored_fields
+        self.ignored_types = ignored_types
+        super().__init__(*args, **kwargs)
+
+    def check_required_fields(self, test_case: TestCase, response: HttpResponse):
+        """Check if the response contains the expected form values."""
+        parser = FormHTMLParser(
+            form_id=self.form_id,
+            ignored_types=self.ignored_types,
+            ignored_fields=self.ignored_fields,
+        )
+        parser.feed(response.content.decode())
+        test_case.assertEqual(self.required_fields, parser.form_fields)
+
+
+class JsonValidator:
+    """Validate a JSONResponse."""
+
+    def __init__(self, value):
+        """Initialize the object with the expected JSON."""
+        self.value = value
+
+    def __call__(self, test_case: TestCase, response: JsonResponse):
+        """Check the content of a JsonResponse."""
+        content = json.loads(response.content)
+        if self.value != content:
+            print(content)
+        test_case.assertEqual(self.value, content)