From 751b007c9840de9cb4e5fc622e8ea9f44e5554ca Mon Sep 17 00:00:00 2001 From: Preston Timmons Date: Sat, 6 Apr 2013 12:09:44 -0500 Subject: [PATCH] Modified test_utils to work with unittest2 discovery. --- django/test/simple.py | 19 +++---- tests/test_utils/doctest_output.py | 77 ++++++++++++++++++++++++++++ tests/test_utils/tests.py | 82 +++--------------------------- 3 files changed, 95 insertions(+), 83 deletions(-) create mode 100644 tests/test_utils/doctest_output.py diff --git a/django/test/simple.py b/django/test/simple.py index 7195d94a3a..6804b4958c 100644 --- a/django/test/simple.py +++ b/django/test/simple.py @@ -42,6 +42,13 @@ def get_tests(app_module): return test_module +def make_doctest(module): + return doctest.DocTestSuite(module, + checker=doctestOutputChecker, + runner=DocTestRunner, + ) + + def build_suite(app_module): """ Create a complete Django test suite for the provided application module. @@ -56,9 +63,7 @@ def build_suite(app_module): suite.addTest(unittest.defaultTestLoader.loadTestsFromModule( app_module)) try: - suite.addTest(doctest.DocTestSuite(app_module, - checker=doctestOutputChecker, - runner=DocTestRunner)) + suite.addTest(make_doctest(app_module)) except ValueError: # No doc tests in models.py pass @@ -75,9 +80,7 @@ def build_suite(app_module): suite.addTest(unittest.defaultTestLoader.loadTestsFromModule( test_module)) try: - suite.addTest(doctest.DocTestSuite( - test_module, checker=doctestOutputChecker, - runner=DocTestRunner)) + suite.addTest(make_doctest(test_module)) except ValueError: # No doc tests in tests.py pass @@ -130,9 +133,7 @@ def build_test(label): tests = [] for module in app_module, test_module: try: - doctests = doctest.DocTestSuite(module, - checker=doctestOutputChecker, - runner=DocTestRunner) + doctests = make_doctest(module) # Now iterate over the suite, looking for doctests whose name # matches the pattern that was given for test in doctests: diff --git a/tests/test_utils/doctest_output.py b/tests/test_utils/doctest_output.py new file mode 100644 index 0000000000..724364428a --- /dev/null +++ b/tests/test_utils/doctest_output.py @@ -0,0 +1,77 @@ +from django.utils import six + +__test__ = {"API_TEST": r""" +# Some checks of the doctest output normalizer. +# Standard doctests do fairly +>>> import json +>>> from django.utils.xmlutils import SimplerXMLGenerator +>>> from django.utils.six import StringIO + +>>> def produce_json(): +... return json.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() + +# 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() +'\nHelloGoodbye' + +>>> produce_xml() +'\nHelloGoodbye' + +>>> produce_xml_fragment() +'Hello' + +>>> produce_xml_fragment() +'Hello' + +"""} + +if not six.PY3: + __test__["API_TEST"] += """ +>>> def produce_long(): +... return 42L + +>>> def produce_int(): +... return 42 + +# Long values are normalized and are comparable to normal integers ... +>>> produce_long() +42 + +# ... and vice versa +>>> produce_int() +42L +""" diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py index f0cfac7594..554f77adca 100644 --- a/tests/test_utils/tests.py +++ b/tests/test_utils/tests.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- from __future__ import absolute_import, unicode_literals +from StringIO import StringIO import warnings from django.db import connection @@ -8,8 +9,10 @@ from django.http import HttpResponse from django.template.loader import render_to_string from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature from django.test.html import HTMLParseError, parse_html +from django.test.simple import make_doctest from django.test.utils import CaptureQueriesContext from django.utils import six +from django.utils import unittest from django.utils.unittest import skip from .models import Person @@ -621,79 +624,10 @@ class AssertFieldOutputTests(SimpleTestCase): } self.assertFieldOutput(MyCustomField, {}, {}, empty_value=None) -__test__ = {"API_TEST": r""" -# Some checks of the doctest output normalizer. -# Standard doctests do fairly ->>> import json ->>> from django.utils.xmlutils import SimplerXMLGenerator ->>> from django.utils.six import StringIO ->>> def produce_json(): -... return json.dumps(['foo', {'bar': ('baz', None, 1.0, 2), 'whiz': 42}]) +class DoctestNormalizerTest(SimpleTestCase): ->>> 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() - -# 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() -'\nHelloGoodbye' - ->>> produce_xml() -'\nHelloGoodbye' - ->>> produce_xml_fragment() -'Hello' - ->>> produce_xml_fragment() -'Hello' - -"""} - -if not six.PY3: - __test__["API_TEST"] += """ ->>> def produce_long(): -... return 42L - ->>> def produce_int(): -... return 42 - -# Long values are normalized and are comparable to normal integers ... ->>> produce_long() -42 - -# ... and vice versa ->>> produce_int() -42L - -""" + def test_normalizer(self): + suite = make_doctest("test_utils.doctest_output") + failures = unittest.TextTestRunner(stream=StringIO()).run(suite) + self.assertEqual(failures.failures, [])