/tests/regressiontests/test_utils/tests.py
Python | 562 lines | 519 code | 41 blank | 2 comment | 36 complexity | d3251c620379ecc4fca3772570802553 MD5 | raw file
Possible License(s): BSD-3-Clause
- # -*- coding: utf-8 -*-
- from __future__ import with_statement, absolute_import
- from django.forms import EmailField, IntegerField
- from django.http import HttpResponse
- from django.template.loader import render_to_string
- from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
- from django.utils.unittest import skip
- from .models import Person
- class SkippingTestCase(TestCase):
- def test_skip_unless_db_feature(self):
- "A test that might be skipped is actually called."
- # Total hack, but it works, just want an attribute that's always true.
- @skipUnlessDBFeature("__class__")
- def test_func():
- raise ValueError
- self.assertRaises(ValueError, test_func)
- class AssertNumQueriesTests(TestCase):
- urls = 'regressiontests.test_utils.urls'
- def test_assert_num_queries(self):
- def test_func():
- raise ValueError
- self.assertRaises(ValueError,
- self.assertNumQueries, 2, test_func
- )
- def test_assert_num_queries_with_client(self):
- person = Person.objects.create(name='test')
- self.assertNumQueries(
- 1,
- self.client.get,
- "/test_utils/get_person/%s/" % person.pk
- )
- self.assertNumQueries(
- 1,
- self.client.get,
- "/test_utils/get_person/%s/" % person.pk
- )
- def test_func():
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- self.assertNumQueries(2, test_func)
- class AssertNumQueriesContextManagerTests(TestCase):
- urls = 'regressiontests.test_utils.urls'
- def test_simple(self):
- with self.assertNumQueries(0):
- pass
- with self.assertNumQueries(1):
- Person.objects.count()
- with self.assertNumQueries(2):
- Person.objects.count()
- Person.objects.count()
- def test_failure(self):
- with self.assertRaises(AssertionError) as exc_info:
- with self.assertNumQueries(2):
- Person.objects.count()
- self.assertIn("1 queries executed, 2 expected", str(exc_info.exception))
- with self.assertRaises(TypeError):
- with self.assertNumQueries(4000):
- raise TypeError
- def test_with_client(self):
- person = Person.objects.create(name="test")
- with self.assertNumQueries(1):
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- with self.assertNumQueries(1):
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- with self.assertNumQueries(2):
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- self.client.get("/test_utils/get_person/%s/" % person.pk)
- class AssertTemplateUsedContextManagerTests(TestCase):
- def test_usage(self):
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/base.html')
- with self.assertTemplateUsed(template_name='template_used/base.html'):
- render_to_string('template_used/base.html')
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/include.html')
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/extends.html')
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/base.html')
- render_to_string('template_used/base.html')
- def test_nested_usage(self):
- with self.assertTemplateUsed('template_used/base.html'):
- with self.assertTemplateUsed('template_used/include.html'):
- render_to_string('template_used/include.html')
- with self.assertTemplateUsed('template_used/extends.html'):
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/extends.html')
- with self.assertTemplateUsed('template_used/base.html'):
- with self.assertTemplateUsed('template_used/alternative.html'):
- render_to_string('template_used/alternative.html')
- render_to_string('template_used/base.html')
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/extends.html')
- with self.assertTemplateNotUsed('template_used/base.html'):
- render_to_string('template_used/alternative.html')
- render_to_string('template_used/base.html')
- def test_not_used(self):
- with self.assertTemplateNotUsed('template_used/base.html'):
- pass
- with self.assertTemplateNotUsed('template_used/alternative.html'):
- pass
- def test_error_message(self):
- with self.assertRaisesRegexp(AssertionError, r'^template_used/base\.html'):
- with self.assertTemplateUsed('template_used/base.html'):
- pass
- with self.assertRaisesRegexp(AssertionError, r'^template_used/base\.html'):
- with self.assertTemplateUsed(template_name='template_used/base.html'):
- pass
- with self.assertRaisesRegexp(AssertionError, r'^template_used/base\.html.*template_used/alternative\.html$'):
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/alternative.html')
- def test_failure(self):
- with self.assertRaises(TypeError):
- with self.assertTemplateUsed():
- pass
- with self.assertRaises(AssertionError):
- with self.assertTemplateUsed(''):
- pass
- with self.assertRaises(AssertionError):
- with self.assertTemplateUsed(''):
- render_to_string('template_used/base.html')
- with self.assertRaises(AssertionError):
- with self.assertTemplateUsed(template_name=''):
- pass
- with self.assertRaises(AssertionError):
- with self.assertTemplateUsed('template_used/base.html'):
- render_to_string('template_used/alternative.html')
- class SaveRestoreWarningState(TestCase):
- def test_save_restore_warnings_state(self):
- """
- Ensure save_warnings_state/restore_warnings_state work correctly.
- """
- # In reality this test could be satisfied by many broken implementations
- # of save_warnings_state/restore_warnings_state (e.g. just
- # warnings.resetwarnings()) , but it is difficult to test more.
- import warnings
- self.save_warnings_state()
- class MyWarning(Warning):
- pass
- # Add a filter that causes an exception to be thrown, so we can catch it
- warnings.simplefilter("error", MyWarning)
- self.assertRaises(Warning, lambda: warnings.warn("warn", MyWarning))
- # Now restore.
- self.restore_warnings_state()
- # After restoring, we shouldn't get an exception. But we don't want a
- # warning printed either, so we have to silence the warning.
- warnings.simplefilter("ignore", MyWarning)
- warnings.warn("warn", MyWarning)
- # Remove the filter we just added.
- self.restore_warnings_state()
- class HTMLEqualTests(TestCase):
- def test_html_parser(self):
- from django.test.html import parse_html
- element = parse_html('<div><p>Hello</p></div>')
- self.assertEqual(len(element.children), 1)
- self.assertEqual(element.children[0].name, 'p')
- self.assertEqual(element.children[0].children[0], 'Hello')
- parse_html('<p>')
- parse_html('<p attr>')
- dom = parse_html('<p>foo')
- self.assertEqual(len(dom.children), 1)
- self.assertEqual(dom.name, 'p')
- self.assertEqual(dom[0], 'foo')
- def test_parse_html_in_script(self):
- from django.test.html import parse_html
- parse_html('<script>var a = "<p" + ">";</script>');
- parse_html('''
- <script>
- var js_sha_link='<p>***</p>';
- </script>
- ''')
- # script content will be parsed to text
- dom = parse_html('''
- <script><p>foo</p> '</scr'+'ipt>' <span>bar</span></script>
- ''')
- self.assertEqual(len(dom.children), 1)
- self.assertEqual(dom.children[0], "<p>foo</p> '</scr'+'ipt>' <span>bar</span>")
- def test_self_closing_tags(self):
- from django.test.html import parse_html
- self_closing_tags = ('br' , 'hr', 'input', 'img', 'meta', 'spacer',
- 'link', 'frame', 'base', 'col')
- for tag in self_closing_tags:
- dom = parse_html('<p>Hello <%s> world</p>' % tag)
- self.assertEqual(len(dom.children), 3)
- self.assertEqual(dom[0], 'Hello')
- self.assertEqual(dom[1].name, tag)
- self.assertEqual(dom[2], 'world')
- dom = parse_html('<p>Hello <%s /> world</p>' % tag)
- self.assertEqual(len(dom.children), 3)
- self.assertEqual(dom[0], 'Hello')
- self.assertEqual(dom[1].name, tag)
- self.assertEqual(dom[2], 'world')
- def test_simple_equal_html(self):
- self.assertHTMLEqual('', '')
- self.assertHTMLEqual('<p></p>', '<p></p>')
- self.assertHTMLEqual('<p></p>', ' <p> </p> ')
- self.assertHTMLEqual(
- '<div><p>Hello</p></div>',
- '<div><p>Hello</p></div>')
- self.assertHTMLEqual(
- '<div><p>Hello</p></div>',
- '<div> <p>Hello</p> </div>')
- self.assertHTMLEqual(
- '<div>\n<p>Hello</p></div>',
- '<div><p>Hello</p></div>\n')
- self.assertHTMLEqual(
- '<div><p>Hello\nWorld !</p></div>',
- '<div><p>Hello World\n!</p></div>')
- self.assertHTMLEqual(
- '<div><p>Hello\nWorld !</p></div>',
- '<div><p>Hello World\n!</p></div>')
- self.assertHTMLEqual(
- '<p>Hello World !</p>',
- '<p>Hello World\n\n!</p>')
- self.assertHTMLEqual('<p> </p>', '<p></p>')
- self.assertHTMLEqual('<p/>', '<p></p>')
- self.assertHTMLEqual('<p />', '<p></p>')
- self.assertHTMLEqual('<input checked>', '<input checked="checked">')
- self.assertHTMLEqual('<p>Hello', '<p> Hello')
- self.assertHTMLEqual('<p>Hello</p>World', '<p>Hello</p> World')
- def test_ignore_comments(self):
- self.assertHTMLEqual(
- '<div>Hello<!-- this is a comment --> World!</div>',
- '<div>Hello World!</div>')
- def test_unequal_html(self):
- self.assertHTMLNotEqual('<p>Hello</p>', '<p>Hello!</p>')
- self.assertHTMLNotEqual('<p>foobar</p>', '<p>foo bar</p>')
- self.assertHTMLNotEqual('<p>foo bar</p>', '<p>foo bar</p>')
- self.assertHTMLNotEqual('<p>foo nbsp</p>', '<p>foo </p>')
- self.assertHTMLNotEqual('<p>foo #20</p>', '<p>foo </p>')
- self.assertHTMLNotEqual(
- '<p><span>Hello</span><span>World</span></p>',
- '<p><span>Hello</span>World</p>')
- self.assertHTMLNotEqual(
- '<p><span>Hello</span>World</p>',
- '<p><span>Hello</span><span>World</span></p>')
- def test_attributes(self):
- self.assertHTMLEqual(
- '<input type="text" id="id_name" />',
- '<input id="id_name" type="text" />')
- self.assertHTMLEqual(
- '''<input type='text' id="id_name" />''',
- '<input id="id_name" type="text" />')
- self.assertHTMLNotEqual(
- '<input type="text" id="id_name" />',
- '<input type="password" id="id_name" />')
- def test_complex_examples(self):
- self.assertHTMLEqual(
- """<tr><th><label for="id_first_name">First name:</label></th>
- <td><input type="text" name="first_name" value="John" id="id_first_name" /></td></tr>
- <tr><th><label for="id_last_name">Last name:</label></th>
- <td><input type="text" id="id_last_name" name="last_name" value="Lennon" /></td></tr>
- <tr><th><label for="id_birthday">Birthday:</label></th>
- <td><input type="text" value="1940-10-9" name="birthday" id="id_birthday" /></td></tr>""",
- """
- <tr><th>
- <label for="id_first_name">First name:</label></th><td><input type="text" name="first_name" value="John" id="id_first_name" />
- </td></tr>
- <tr><th>
- <label for="id_last_name">Last name:</label></th><td><input type="text" name="last_name" value="Lennon" id="id_last_name" />
- </td></tr>
- <tr><th>
- <label for="id_birthday">Birthday:</label></th><td><input type="text" name="birthday" value="1940-10-9" id="id_birthday" />
- </td></tr>
- """)
- self.assertHTMLEqual(
- """<!DOCTYPE html>
- <html>
- <head>
- <link rel="stylesheet">
- <title>Document</title>
- <meta attribute="value">
- </head>
- <body>
- <p>
- This is a valid paragraph
- <div> this is a div AFTER the p</div>
- </body>
- </html>""", """
- <html>
- <head>
- <link rel="stylesheet">
- <title>Document</title>
- <meta attribute="value">
- </head>
- <body>
- <p> This is a valid paragraph
- <!-- browsers would close the p tag here -->
- <div> this is a div AFTER the p</div>
- </p> <!-- this is invalid HTML parsing, but it should make no
- difference in most cases -->
- </body>
- </html>""")
- def test_html_contain(self):
- from django.test.html import parse_html
- # equal html contains each other
- dom1 = parse_html('<p>foo')
- dom2 = parse_html('<p>foo</p>')
- self.assertTrue(dom1 in dom2)
- self.assertTrue(dom2 in dom1)
- dom2 = parse_html('<div><p>foo</p></div>')
- self.assertTrue(dom1 in dom2)
- self.assertTrue(dom2 not in dom1)
- self.assertFalse('<p>foo</p>' in dom2)
- self.assertTrue('foo' in dom2)
- # when a root element is used ...
- dom1 = parse_html('<p>foo</p><p>bar</p>')
- dom2 = parse_html('<p>foo</p><p>bar</p>')
- self.assertTrue(dom1 in dom2)
- dom1 = parse_html('<p>foo</p>')
- self.assertTrue(dom1 in dom2)
- dom1 = parse_html('<p>bar</p>')
- self.assertTrue(dom1 in dom2)
- def test_count(self):
- from django.test.html import parse_html
- # equal html contains each other one time
- dom1 = parse_html('<p>foo')
- dom2 = parse_html('<p>foo</p>')
- self.assertEqual(dom1.count(dom2), 1)
- self.assertEqual(dom2.count(dom1), 1)
- dom2 = parse_html('<p>foo</p><p>bar</p>')
- self.assertEqual(dom2.count(dom1), 1)
- dom2 = parse_html('<p>foo foo</p><p>foo</p>')
- self.assertEqual(dom2.count('foo'), 3)
- dom2 = parse_html('<p class="bar">foo</p>')
- self.assertEqual(dom2.count('bar'), 0)
- self.assertEqual(dom2.count('class'), 0)
- self.assertEqual(dom2.count('p'), 0)
- self.assertEqual(dom2.count('o'), 2)
- dom2 = parse_html('<p>foo</p><p>foo</p>')
- self.assertEqual(dom2.count(dom1), 2)
- dom2 = parse_html('<div><p>foo<input type=""></p><p>foo</p></div>')
- self.assertEqual(dom2.count(dom1), 1)
- dom2 = parse_html('<div><div><p>foo</p></div></div>')
- self.assertEqual(dom2.count(dom1), 1)
- dom2 = parse_html('<p>foo<p>foo</p></p>')
- self.assertEqual(dom2.count(dom1), 1)
- dom2 = parse_html('<p>foo<p>bar</p></p>')
- self.assertEqual(dom2.count(dom1), 0)
- def test_parsing_errors(self):
- from django.test.html import HTMLParseError, parse_html
- with self.assertRaises(AssertionError):
- self.assertHTMLEqual('<p>', '')
- with self.assertRaises(AssertionError):
- self.assertHTMLEqual('', '<p>')
- with self.assertRaises(HTMLParseError):
- parse_html('</p>')
- def test_contains_html(self):
- response = HttpResponse('''<body>
- This is a form: <form action="" method="get">
- <input type="text" name="Hello" />
- </form></body>''')
- self.assertNotContains(response, "<input name='Hello' type='text'>")
- self.assertContains(response, '<form action="" method="get">')
- self.assertContains(response, "<input name='Hello' type='text'>", html=True)
- self.assertNotContains(response, '<form action="" method="get">', html=True)
- invalid_response = HttpResponse('''<body <bad>>''')
- with self.assertRaises(AssertionError):
- self.assertContains(invalid_response, '<p></p>')
- with self.assertRaises(AssertionError):
- self.assertContains(response, '<p "whats" that>')
- def test_unicode_handling(self):
- from django.http import HttpResponse
- response = HttpResponse('<p class="help">Some help text for the title (with unicode ŠĐĆŽćžšđ)</p>')
- self.assertContains(response, '<p class="help">Some help text for the title (with unicode ŠĐĆŽćžšđ)</p>', html=True)
- class SkippingExtraTests(TestCase):
- fixtures = ['should_not_be_loaded.json']
- # HACK: This depends on internals of our TestCase subclasses
- def __call__(self, result=None):
- # Detect fixture loading by counting SQL queries, should be zero
- with self.assertNumQueries(0):
- super(SkippingExtraTests, self).__call__(result)
- @skip("Fixture loading should not be performed for skipped tests.")
- def test_fixtures_are_skipped(self):
- pass
- class AssertRaisesMsgTest(SimpleTestCase):
- def test_special_re_chars(self):
- """assertRaisesMessage shouldn't interpret RE special chars."""
- def func1():
- raise ValueError("[.*x+]y?")
- self.assertRaisesMessage(ValueError, "[.*x+]y?", func1)
- class AssertFieldOutputTests(SimpleTestCase):
- def test_assert_field_output(self):
- error_invalid = [u'Enter a valid e-mail address.']
- self.assertFieldOutput(EmailField, {'a@a.com': 'a@a.com'}, {'aaa': error_invalid})
- self.assertRaises(AssertionError, self.assertFieldOutput, EmailField, {'a@a.com': 'a@a.com'}, {'aaa': error_invalid + [u'Another error']})
- self.assertRaises(AssertionError, self.assertFieldOutput, EmailField, {'a@a.com': 'Wrong output'}, {'aaa': error_invalid})
- self.assertRaises(AssertionError, self.assertFieldOutput, EmailField, {'a@a.com': 'a@a.com'}, {'aaa': [u'Come on, gimme some well formatted data, dude.']})
- def test_custom_required_message(self):
- class MyCustomField(IntegerField):
- default_error_messages = {
- 'required': u'This is really required.',
- }
- self.assertFieldOutput(MyCustomField, {}, {}, empty_value=None)
- __test__ = {"API_TEST": r"""
- # Some checks of the doctest output normalizer.
- # Standard doctests do fairly
- >>> from django.utils import simplejson
- >>> from django.utils.xmlutils import SimplerXMLGenerator
- >>> from StringIO import StringIO
- >>> def produce_long():
- ... return 42L
- >>> def produce_int():
- ... return 42
- >>> def produce_json():
- ... return simplejson.dumps(['foo', {'bar': ('baz', None, 1.0, 2), 'whiz': 42}])
- >>> def produce_xml():
- ... stream = StringIO()
- ... xml = SimplerXMLGenerator(stream, encoding='utf-8')
- ... xml.startDocument()
- ... xml.startElement("foo", {"aaa" : "1.0", "bbb": "2.0"})
- ... xml.startElement("bar", {"ccc" : "3.0"})
- ... xml.characters("Hello")
- ... xml.endElement("bar")
- ... xml.startElement("whiz", {})
- ... xml.characters("Goodbye")
- ... xml.endElement("whiz")
- ... xml.endElement("foo")
- ... xml.endDocument()
- ... return stream.getvalue()
- >>> def produce_xml_fragment():
- ... stream = StringIO()
- ... xml = SimplerXMLGenerator(stream, encoding='utf-8')
- ... xml.startElement("foo", {"aaa": "1.0", "bbb": "2.0"})
- ... xml.characters("Hello")
- ... xml.endElement("foo")
- ... xml.startElement("bar", {"ccc": "3.0", "ddd": "4.0"})
- ... xml.endElement("bar")
- ... return stream.getvalue()
- # Long values are normalized and are comparable to normal integers ...
- >>> produce_long()
- 42
- # ... and vice versa
- >>> produce_int()
- 42L
- # JSON output is normalized for field order, so it doesn't matter
- # which order json dictionary attributes are listed in output
- >>> produce_json()
- '["foo", {"bar": ["baz", null, 1.0, 2], "whiz": 42}]'
- >>> produce_json()
- '["foo", {"whiz": 42, "bar": ["baz", null, 1.0, 2]}]'
- # XML output is normalized for attribute order, so it doesn't matter
- # which order XML element attributes are listed in output
- >>> produce_xml()
- '<?xml version="1.0" encoding="UTF-8"?>\n<foo aaa="1.0" bbb="2.0"><bar ccc="3.0">Hello</bar><whiz>Goodbye</whiz></foo>'
- >>> produce_xml()
- '<?xml version="1.0" encoding="UTF-8"?>\n<foo bbb="2.0" aaa="1.0"><bar ccc="3.0">Hello</bar><whiz>Goodbye</whiz></foo>'
- >>> produce_xml_fragment()
- '<foo aaa="1.0" bbb="2.0">Hello</foo><bar ccc="3.0" ddd="4.0"></bar>'
- >>> produce_xml_fragment()
- '<foo bbb="2.0" aaa="1.0">Hello</foo><bar ddd="4.0" ccc="3.0"></bar>'
- """}