Ticket #5419: fuzz.2.patch

django/test/testcases.py

@@ -38 +38 @@
 from django.test.signals import template_rendered
 from django.test.utils import (get_warnings_state, restore_warnings_state,
     override_settings, compare_xml, strip_quotes)
-from django.test.utils import ContextList
+from django.test.utils import ContextList, generate_fuzzy_value
 from django.utils import unittest as ut2
 from django.utils.encoding import force_text
 from django.utils import six
@@ -391 +391 @@
                 standardMsg = '%s == %s' % (safe_repr(xml1, True), safe_repr(xml2, True))
                 self.fail(self._formatMessage(msg, standardMsg))
 
+    def assertModelUnicodePassesFuzzTest(self, model, repeat=10):
+        """
+        Asserts that after having assigned random unicode data into each of
+        the fields of an instance of the specified model that calling the
+        __unicode__ method of the instance doesn't raise a UnicodeError.
+        Random data is assigned and the __unicode__ method called repeat times.
+        """
+        instance = model()
+        opts = model._meta
+        for i in range(repeat):
+            for field in opts.fields:
+                setattr(instance, field.name, generate_fuzzy_value(str))
+            try:
+                if six.PY3:
+                    six.u(instance)
+                else:
+                    unicode(instance)
+            except UnicodeError as e:
+                self.fail("Model '%s' unexpectedly raised %s when"
+                          " converting to unicode: %s" % (
+                          model.__name__, e.__class__.__name__, e))
+
+    def assertFunctionPassesFuzzTest(self, func, arg_types=(),
+                                     permitted_return_types=(),
+                                     permitted_exceptions=(), repeat=10):
+        """
+        Asserts that the function when called with random values of the types
+        specified by arg_types that the return value has a type from
+        permitted_return_types and that if an exception is raised it is one
+        that is in permitted_exceptions. The function is called repeat times
+        with random data.
+        """
+
+        def isiterable(o):
+            try:
+                iter(o)
+            except TypeError:
+                return False
+            return True
+
+        def cartesian_product(L, *lists):
+            if not lists:
+                for x in L:
+                    yield (x,)
+            else:
+                for x in L:
+                    for y in cartesian_product(lists[0], *lists[1:]):
+                        yield (x,) + y
+
+        # Allow the use of None
+        if (None in permitted_return_types) and (
+            None not in permitted_return_types
+        ):
+            permitted_return_types = list(permitted_return_types)
+            permitted_return_types += (None,)
+
+        arg_types = list(arg_types)
+        # Ensure arg_types is a sequence of iterables
+        for i, arg_type in enumerate(arg_types):
+            if not isiterable(arg_type):
+                arg_types[i] = (arg_type,)
+
+        for i in range(repeat):
+            for atypes in cartesian_product(*arg_types):
+                args = []
+                for arg_type in atypes:
+                    args.append(generate_fuzzy_value(arg_type))
+                try:
+                    return_value = func(*args)
+                except:
+                    if permitted_exceptions:
+                        exc_type, exc_value = sys.exc_info()[:2]
+                        if exc_type not in permitted_exceptions:
+                            self.fail("Unexpected %s encountered when calling"
+                                      " %s with inputs %r: %s" % (
+                                      exc_type.__name__, func.__name__,
+                                      args, exc_value))
+                else:
+                    if permitted_return_types and return_value and (
+                        type(return_value) not in permitted_return_types
+                    ):
+                        self.fail("Unexpected return value type %s encountered"
+                                  " when calling %s with inputs %r." % (
+                                  return_value.__name__, func.__name__, args))
+
 
 class TransactionTestCase(SimpleTestCase):
 

django/test/utils.py

@@ +1 @@
+import random
 import re
+import sys
 import warnings
 from xml.dom.minidom import parseString, Node
 
@@ -11 +13 @@
 from django.utils.functional import wraps
 from django.utils import six
 
+try:
+    unichr
+except NameError:  # Python 3
+    unichr = chr
+
 
 __all__ = (
     'Approximate', 'ContextList',  'get_runner', 'override_settings',
     'setup_test_environment', 'teardown_test_environment',
+    'generate_fuzzy_value'
 )
 
 RESTORE_LOADERS_ATTR = '_original_template_source_loaders'
@@ -321 +329 @@
         got = got.strip()[2:-1]
     return want, got
 
+
 def str_prefix(s):
     return s % {'_': '' if six.PY3 else 'u'}
+
+
+def generate_fuzzy_value(value_type):
+    """
+    Returns a randome value of the specified type, or raises a ValueError if
+    the type is not supported. If value_type is callable then it is called and
+    its return value is returned. This allows you to specify a function that
+    generates a random value of a type that isn't supported.
+    """
+    if value_type is None:
+        return None
+    if issubclass(value_type, bool):
+        return random.choice((True, False))
+    if issubclass(value_type, six.integer_types):
+        return random.randint(-six.MAXSIZE - 1, six.MAXSIZE)
+    if issubclass(value_type, float):
+        return random.random() * generate_fuzzy_value(int)
+    if issubclass(value_type, six.string_types):
+        length = random.randint(0, 1000)
+        return ''.join([unichr(random.randint(32, 255))
+                        for _ in range(length)])
+    if callable(value_type):
+        return value_type()
+    raise ValueError("Unsupported type: %s" % value_type)

tests/regressiontests/test_utils/models.py

@@ -3 +3 @@
 
 class Person(models.Model):
     name = models.CharField(max_length=100)
+
+    def __unicode__(self):
+        return unicode(self.name)

tests/regressiontests/test_utils/tests.py

@@ -490 +490 @@
         self.assertXMLEqual(xml1, xml2)
 
 
+class FuzzTests(TestCase):
+
+    def test_simple_model_unicode(self):
+        self.assertModelUnicodePassesFuzzTest(Person)
+
+    def test_simple_call_func_with_random_data(self):
+        def _test_func(intarg, intarg2, boolarg):
+            if boolarg:
+                return None
+            elif not boolarg:
+                raise ValueError('error')
+            elif intarg > intarg2:
+                return intarg
+            elif intarg < intarg2:
+                return intarg2
+        self.assertFunctionPassesFuzzTest(_test_func,
+                                          arg_types=((int, None),
+                                                     (int, None), bool),
+                                          permitted_return_types=(None, int),
+                                          permitted_exceptions=(ValueError,),
+                                          repeat=100)
+
+
 class SkippingExtraTests(TestCase):
     fixtures = ['should_not_be_loaded.json']