1 """

     2 Tests for django test runner

     3 """

     4 import StringIO

     5 import unittest

     6 import django

     7 from django.core.exceptions import ImproperlyConfigured

     8 from django.test import simple

     9 

    10 class DjangoTestRunnerTests(unittest.TestCase):

    11 

    12     def test_failfast(self):

    13         class MockTestOne(unittest.TestCase):

    14             def runTest(self):

    15                 assert False

    16         class MockTestTwo(unittest.TestCase):

    17             def runTest(self):

    18                 assert False

    19 

    20         suite = unittest.TestSuite([MockTestOne(), MockTestTwo()])

    21         mock_stream = StringIO.StringIO()

    22         dtr = simple.DjangoTestRunner(verbosity=0, failfast=False, stream=mock_stream)

    23         result = dtr.run(suite)

    24         self.assertEqual(2, result.testsRun)

    25         self.assertEqual(2, len(result.failures))

    26 

    27         dtr = simple.DjangoTestRunner(verbosity=0, failfast=True, stream=mock_stream)

    28         result = dtr.run(suite)

    29         self.assertEqual(1, result.testsRun)

    30         self.assertEqual(1, len(result.failures))

    31 

    32 class DependencyOrderingTests(unittest.TestCase):

    33 

    34     def test_simple_dependencies(self):

    35         raw = [

    36             ('s1', ['alpha']),

    37             ('s2', ['bravo']),

    38             ('s3', ['charlie']),

    39         ]

    40         dependencies = {

    41             'alpha': ['charlie'],

    42             'bravo': ['charlie'],

    43         }

    44 

    45         ordered = simple.dependency_ordered(raw, dependencies=dependencies)

    46         ordered_sigs = [sig for sig,aliases in ordered]

    47 

    48         self.assertTrue('s1' in ordered_sigs)

    49         self.assertTrue('s2' in ordered_sigs)

    50         self.assertTrue('s3' in ordered_sigs)

    51         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))

    52         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))

    53 

    54     def test_chained_dependencies(self):

    55         raw = [

    56             ('s1', ['alpha']),

    57             ('s2', ['bravo']),

    58             ('s3', ['charlie']),

    59         ]

    60         dependencies = {

    61             'alpha': ['bravo'],

    62             'bravo': ['charlie'],

    63         }

    64 

    65         ordered = simple.dependency_ordered(raw, dependencies=dependencies)

    66         ordered_sigs = [sig for sig,aliases in ordered]

    67 

    68         self.assertTrue('s1' in ordered_sigs)

    69         self.assertTrue('s2' in ordered_sigs)

    70         self.assertTrue('s3' in ordered_sigs)

    71 

    72         # Explicit dependencies

    73         self.assertTrue(ordered_sigs.index('s2') < ordered_sigs.index('s1'))

    74         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))

    75 

    76         # Implied dependencies

    77         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))

    78 

    79     def test_multiple_dependencies(self):

    80         raw = [

    81             ('s1', ['alpha']),

    82             ('s2', ['bravo']),

    83             ('s3', ['charlie']),

    84             ('s4', ['delta']),

    85         ]

    86         dependencies = {

    87             'alpha': ['bravo','delta'],

    88             'bravo': ['charlie'],

    89             'delta': ['charlie'],

    90         }

    91 

    92         ordered = simple.dependency_ordered(raw, dependencies=dependencies)

    93         ordered_sigs = [sig for sig,aliases in ordered]

    94 

    95         self.assertTrue('s1' in ordered_sigs)

    96         self.assertTrue('s2' in ordered_sigs)

    97         self.assertTrue('s3' in ordered_sigs)

    98         self.assertTrue('s4' in ordered_sigs)

    99 

   100         # Explicit dependencies

   101         self.assertTrue(ordered_sigs.index('s2') < ordered_sigs.index('s1'))

   102         self.assertTrue(ordered_sigs.index('s4') < ordered_sigs.index('s1'))

   103         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))

   104         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s4'))

   105 

   106         # Implicit dependencies

   107         self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))

   108 

   109     def test_circular_dependencies(self):

   110         raw = [

   111             ('s1', ['alpha']),

   112             ('s2', ['bravo']),

   113         ]

   114         dependencies = {

   115             'bravo': ['alpha'],

   116             'alpha': ['bravo'],

   117         }

   118 

   119         self.assertRaises(ImproperlyConfigured, simple.dependency_ordered, raw, dependencies=dependencies)

   120