744043183

Build Type

push

github

Committed by Dylan Verheul

Commit Message

Add tests for messages

Run Details

22 of 28 branches covered (78.57%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

5 existing lines in 1 file now uncovered.

124 of 130 relevant lines covered (95.38%)

3.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.19

/src/django_marina/test/test_cases.py

from django.contrib.messages import get_messages
from django.test import TestCase

from .clients import ExtendedClient


class ExtendedTestCase(TestCase):
    """TestCase with a extended client and extra features for asserting response content."""

    HTTP_REDIRECT = 302
    HTTP_OK = 200
    HTTP_FORBIDDEN = 403
    HTTP_NOT_FOUND = 404

    client_class = ExtendedClient

    def _response(self, path, user, **kwargs):
        """Return response on a separate client instance, so without any side effects."""
        client = self.client_class()
        method = kwargs.pop("method", "get").lower()
        if method == "get":
            response = client.get(path, user=user, **kwargs)
        elif method == "post":
            response = client.post(path, user=user, **kwargs)
        else:
            raise AssertionError(f"Illegal value {method} for method, expected GET or POST")
        return response

    def assertResponseOk(self, response):
        """
        Assert that response has status HTTP_OK.

        :param response: HttpResponse
        """
        self.assertEqual(response.status_code, self.HTTP_OK, f"Response code should be HTTP_OK ({self.HTTP_OK})")

    def assertLoginRequired(self, path, **kwargs):
        """
        Make request while not logged in, assert that response has status HTTP_FORBIDDEN or HTTP_REDIRECTS.

        :param path: Path for request
        :param kwargs: Kwargs for request
        """
        response = self._response(path, user=None, **kwargs)
        # TODO: Check for proper redirection to login view
        self.assertIn(
            response.status_code,
            (self.HTTP_REDIRECT, self.HTTP_FORBIDDEN),
            (
                f"Response code should either be HTTP_REDIRECT ({self.HTTP_REDIRECT}) "
                f"or HTTP_FORBIDDEN ({self.HTTP_FORBIDDEN})"
            ),
        )

    def assertLoginNotRequired(self, path, **kwargs):
        """
        Make request while not logged in, assert that response has status HTTP_OK.

        :param path: Path for request
        :param kwargs: Kwargs for request
        """
        response = self._response(path, user=None, **kwargs)
        self.assertResponseOk(response)

    def assertAllowed(self, path, user, **kwargs):
        """
        Make request, assert that response has status HTTP_OK.

        Note that we use our own client so there are no side effects.

        :param path: Path for request
        :param user: User for request
        :param kwargs: Kwargs for request
        """
        response = self._response(path, user=user, **kwargs)
        self.assertResponseOk(response)

    def assertForbidden(self, path, user, **kwargs):
        """
        Make request, assert that response has status HTTP_FORBIDDEN.

        Note that we use our own client so there are no side effects.

        :param path: Path for request
        :param user: User for request
        :param kwargs: Kwargs for request
        """
        response = self._response(path, user=user, **kwargs)
        self.assertEqual(response.status_code, self.HTTP_FORBIDDEN)

    def assertNotFound(self, path, user, **kwargs):
        """
        Make request, assert that response has status HTTP_FORBIDDEN.

        Note that we use our own client so there are no side effects.

        :param path: Path for request
        :param user: User for request
        :param kwargs: Kwargs for request
        """
        response = self._response(path, user=user, **kwargs)
        self.assertEqual(response.status_code, self.HTTP_NOT_FOUND)

    def _assert_soup(self, response, soup_method, soup_args, soup_kwargs, status_code, count, msg_prefix):
        """Handle assertions that use BeautifulSoup, with interface similar to assertContains and assertNotContains."""
        if hasattr(response, "render") and callable(response.render) and not response.is_rendered:
            response.render()

        if msg_prefix:
            msg_prefix = f"{msg_prefix}: "

        self.assertEqual(
            response.status_code,
            status_code,
            f"{msg_prefix}Couldn't retrieve content: Response code was {response.status_code} (expected {status_code})",
        )

        text_repr = f"{soup_args} {soup_kwargs}"

        # Extract string kwarg for selectors since soup does not implement it
        string = soup_kwargs.pop("string", None) if soup_method == "select" else None

        method = getattr(response.soup, soup_method)
        results = method(*soup_args, **soup_kwargs)

        # Search with string kwarg for selectors, by applying it to found tags
        if string is not None:
            results = [result for result in results if result.find(string=string)]

        real_count = len(results)

        if count == 0:  # No results should be found.
            self.assertEqual(real_count, 0, f"{msg_prefix}Response should not contain {text_repr}")
        elif count is None:  # At least one result should be found.
            self.assertTrue(real_count != 0, f"{msg_prefix}Couldn't find {text_repr} in response")
        else:  # Exactly this number of results should be found.
            self.assertEqual(
                real_count,
                count,
                f"{msg_prefix}Found {real_count} instances of {text_repr} in response (expected {count})",
            )

    def assertContainsTag(self, response, name=None, count=None, status_code=200, msg_prefix="", **kwargs):
        """
        Assert that tag can be found in response, using BeautifulSoup find notation.

        Documentation on tag finding: https://www.crummy.com/software/BeautifulSoup/bs4/doc/#kinds-of-filters
        """
        self._assert_soup(
            response,
            soup_method="find_all",
            soup_args=[name],
            soup_kwargs=kwargs,
            status_code=status_code,
            count=count,
            msg_prefix=msg_prefix,
        )

    def assertNotContainsTag(self, response, name=None, status_code=200, msg_prefix="", **kwargs):
        """
        Assert that tag cannot be found in response, using BeautifulSoup find notation.

        See `assertContainsTag` for documentation.
        """
        self._assert_soup(
            response,
            soup_method="find_all",
            soup_args=[name],
            soup_kwargs=kwargs,
            status_code=status_code,
            count=0,
            msg_prefix=msg_prefix,
        )

    def assertContainsSelector(self, response, selector, count=None, status_code=200, msg_prefix="", **kwargs):
        """
        Assert that CSS selector can be found in response.

        Documentation on CSS selectors:
        https://www.crummy.com/software/BeautifulSoup/bs4/doc/#css-selectors

        To search within the found selectors, you can optionally provide a `string` argument. This will filter
        the found tags. See https://www.crummy.com/software/BeautifulSoup/bs4/doc/#the-string-argument
        """
        self._assert_soup(
            response,
            soup_method="select",
            soup_args=[selector],
            soup_kwargs=kwargs,
            status_code=status_code,
            count=count,
            msg_prefix=msg_prefix,
        )

    def assertNotContainsSelector(self, response, selector, status_code=200, msg_prefix="", **kwargs):
        """Assert that CSS selector cannot be found in response."""
        self._assert_soup(
            response,
            soup_method="select",
            soup_args=[selector],
            soup_kwargs=kwargs,
            status_code=status_code,
            count=0,
            msg_prefix=msg_prefix,
        )

    def assertHasMessage(self, response, message):
        """Assert that response has given message."""
        self.assertIn(message, [m.message for m in get_messages(response.wsgi_request)])

1	from django.contrib.messages import get_messages	4✔
2	from django.test import TestCase	4✔
3
4	from .clients import ExtendedClient	4✔
5
6
7	class ExtendedTestCase(TestCase):	4✔
8	"""TestCase with a extended client and extra features for asserting response content."""
9
10	HTTP_REDIRECT = 302	4✔
11	HTTP_OK = 200	4✔
12	HTTP_FORBIDDEN = 403	4✔
13	HTTP_NOT_FOUND = 404	4✔
14
15	client_class = ExtendedClient	4✔
16
17	def _response(self, path, user, **kwargs):	4✔
18	"""Return response on a separate client instance, so without any side effects."""
19	client = self.client_class()	4✔
20	method = kwargs.pop("method", "get").lower()	4✔
21	if method == "get":	4!
22	response = client.get(path, user=user, **kwargs)	4✔
UNCOV 23	elif method == "post":	×
24	response = client.post(path, user=user, **kwargs)	×
25	else:
UNCOV 26	raise AssertionError(f"Illegal value {method} for method, expected GET or POST")	×
27	return response	4✔
28
29	def assertResponseOk(self, response):	4✔
30	"""
31	Assert that response has status HTTP_OK.
32
33	:param response: HttpResponse
34	"""
35	self.assertEqual(response.status_code, self.HTTP_OK, f"Response code should be HTTP_OK ({self.HTTP_OK})")	4✔
36
37	def assertLoginRequired(self, path, **kwargs):	4✔
38	"""
39	Make request while not logged in, assert that response has status HTTP_FORBIDDEN or HTTP_REDIRECTS.
40
41	:param path: Path for request
42	:param kwargs: Kwargs for request
43	"""
44	response = self._response(path, user=None, **kwargs)	4✔
45	# TODO: Check for proper redirection to login view
46	self.assertIn(	4✔
47	response.status_code,
48	(self.HTTP_REDIRECT, self.HTTP_FORBIDDEN),
49	(
50	f"Response code should either be HTTP_REDIRECT ({self.HTTP_REDIRECT}) "
51	f"or HTTP_FORBIDDEN ({self.HTTP_FORBIDDEN})"
52	),
53	)
54
55	def assertLoginNotRequired(self, path, **kwargs):	4✔
56	"""
57	Make request while not logged in, assert that response has status HTTP_OK.
58
59	:param path: Path for request
60	:param kwargs: Kwargs for request
61	"""
62	response = self._response(path, user=None, **kwargs)	4✔
63	self.assertResponseOk(response)	4✔
64
65	def assertAllowed(self, path, user, **kwargs):	4✔
66	"""
67	Make request, assert that response has status HTTP_OK.
68
69	Note that we use our own client so there are no side effects.
70
71	:param path: Path for request
72	:param user: User for request
73	:param kwargs: Kwargs for request
74	"""
75	response = self._response(path, user=user, **kwargs)	4✔
76	self.assertResponseOk(response)	4✔
77
78	def assertForbidden(self, path, user, **kwargs):	4✔
79	"""
80	Make request, assert that response has status HTTP_FORBIDDEN.
81
82	Note that we use our own client so there are no side effects.
83
84	:param path: Path for request
85	:param user: User for request
86	:param kwargs: Kwargs for request
87	"""
88	response = self._response(path, user=user, **kwargs)	4✔
89	self.assertEqual(response.status_code, self.HTTP_FORBIDDEN)	4✔
90
91	def assertNotFound(self, path, user, **kwargs):	4✔
92	"""
93	Make request, assert that response has status HTTP_FORBIDDEN.
94
95	Note that we use our own client so there are no side effects.
96
97	:param path: Path for request
98	:param user: User for request
99	:param kwargs: Kwargs for request
100	"""
101	response = self._response(path, user=user, **kwargs)	4✔
102	self.assertEqual(response.status_code, self.HTTP_NOT_FOUND)	4✔
103
104	def _assert_soup(self, response, soup_method, soup_args, soup_kwargs, status_code, count, msg_prefix):	4✔
105	"""Handle assertions that use BeautifulSoup, with interface similar to assertContains and assertNotContains."""
106	if hasattr(response, "render") and callable(response.render) and not response.is_rendered:	4!
UNCOV 107	response.render()	×
108
109	if msg_prefix:	4!
UNCOV 110	msg_prefix = f"{msg_prefix}: "	×
111
112	self.assertEqual(	4✔
113	response.status_code,
114	status_code,
115	f"{msg_prefix}Couldn't retrieve content: Response code was {response.status_code} (expected {status_code})",
116	)
117
118	text_repr = f"{soup_args} {soup_kwargs}"	4✔
119
120	# Extract string kwarg for selectors since soup does not implement it
121	string = soup_kwargs.pop("string", None) if soup_method == "select" else None	4✔
122
123	method = getattr(response.soup, soup_method)	4✔
124	results = method(soup_args, *soup_kwargs)	4✔
125
126	# Search with string kwarg for selectors, by applying it to found tags
127	if string is not None:	4✔
128	results = [result for result in results if result.find(string=string)]	4✔
129
130	real_count = len(results)	4✔
131
132	if count == 0: # No results should be found.	4✔
133	self.assertEqual(real_count, 0, f"{msg_prefix}Response should not contain {text_repr}")	4✔
134	elif count is None: # At least one result should be found.	4!
135	self.assertTrue(real_count != 0, f"{msg_prefix}Couldn't find {text_repr} in response")	4✔
136	else: # Exactly this number of results should be found.
UNCOV 137	self.assertEqual(	×
138	real_count,
139	count,
140	f"{msg_prefix}Found {real_count} instances of {text_repr} in response (expected {count})",
141	)
142
143	def assertContainsTag(self, response, name=None, count=None, status_code=200, msg_prefix="", **kwargs):	4✔
144	"""
145	Assert that tag can be found in response, using BeautifulSoup find notation.
146
147	Documentation on tag finding: https://www.crummy.com/software/BeautifulSoup/bs4/doc/#kinds-of-filters
148	"""
149	self._assert_soup(	4✔
150	response,
151	soup_method="find_all",
152	soup_args=[name],
153	soup_kwargs=kwargs,
154	status_code=status_code,
155	count=count,
156	msg_prefix=msg_prefix,
157	)
158
159	def assertNotContainsTag(self, response, name=None, status_code=200, msg_prefix="", **kwargs):	4✔
160	"""
161	Assert that tag cannot be found in response, using BeautifulSoup find notation.
162
163	See `assertContainsTag` for documentation.
164	"""
165	self._assert_soup(	4✔
166	response,
167	soup_method="find_all",
168	soup_args=[name],
169	soup_kwargs=kwargs,
170	status_code=status_code,
171	count=0,
172	msg_prefix=msg_prefix,
173	)
174
175	def assertContainsSelector(self, response, selector, count=None, status_code=200, msg_prefix="", **kwargs):	4✔
176	"""
177	Assert that CSS selector can be found in response.
178
179	Documentation on CSS selectors:
180	https://www.crummy.com/software/BeautifulSoup/bs4/doc/#css-selectors
181
182	To search within the found selectors, you can optionally provide a `string` argument. This will filter
183	the found tags. See https://www.crummy.com/software/BeautifulSoup/bs4/doc/#the-string-argument
184	"""
185	self._assert_soup(	4✔
186	response,
187	soup_method="select",
188	soup_args=[selector],
189	soup_kwargs=kwargs,
190	status_code=status_code,
191	count=count,
192	msg_prefix=msg_prefix,
193	)
194
195	def assertNotContainsSelector(self, response, selector, status_code=200, msg_prefix="", **kwargs):	4✔
196	"""Assert that CSS selector cannot be found in response."""
197	self._assert_soup(	4✔
198	response,
199	soup_method="select",
200	soup_args=[selector],
201	soup_kwargs=kwargs,
202	status_code=status_code,
203	count=0,
204	msg_prefix=msg_prefix,
205	)
206
207	def assertHasMessage(self, response, message):	4✔
208	"""Assert that response has given message."""
209	self.assertIn(message, [m.message for m in get_messages(response.wsgi_request)])	4✔

zostera / django-marina / 744043183

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous