Login

Deep package test runner

Author:
eternicode
Posted:
March 8, 2011
Language:
Python
Version:
1.0
Score:
0 (after 0 ratings)

NOTE: This is modified from 1.0's test runner and has only been tested on Django 1.0 + Python 2.5

This is a test runner that searches inside any app-level "tests" packages for django unit tests. Modules to be searched must have names that start with "test_" (this can be changed by modifying get_multi_tests(), [mod.startswith('test_') and mod.endswith('.py')]).

It also allows for arbitrarily nested test packages, with no restrictions on naming, so you could have:

myapp/
+- tests/
    +- __init__.py
    +- test_set1.py
    +- category1/
        +- __init__.py
        +- test_something.py
        +- subcat/
            +- __init__.py
            +- test_foobar.py
    +- category2/
        +- __init__.py
        +- test_other.py

and "manage.py test myapp" would pick up tests in all four test_*.py test modules.

Searching the modules in this way, instead of importing them all into the top-level __init__.py, allows you to have "name collisions" with TestCase names -- two modules can each have a TestFooBar class, and they will both be run. Unfortunately, this snippet doesn't allow you to specify a full path to a specific test case or test module ("manage.py test myapp.category1.test_something" and "manage.py test myapp.test_set1.TestFooBar" won't work); using "manage.py test myapp.TestFooBar" will search out all test cases named "TestFooBar" and run them. "manage.py test myapp.TestFooBar.test_baz" will work similarly, returning the test_baz method of each TestFooBar class.

To use, put this code in "testrunner.py" in your project, and add TEST_RUNNER = 'myproject.testrunner.run_tests' to your settings.py.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
'''
This is a custom test runner (modified from Django 1.0's django.test.simple)
to search inside "tests" packages for tests, in addition to "tests" modules.

Ie, if you split an app's tests into a package:

myapp/
 +- tests/
    +- __init__.py
    +- test_set1.py
    +- test_set2.py

Each test_*.py module will be searched for tests.
'''
import unittest
from django.conf import settings
from django.db.models import get_app, get_apps
from django.test import _doctest as doctest
from django.test.utils import setup_test_environment, teardown_test_environment
from django.test.testcases import OutputChecker, DocTestRunner
import pkgutil


# The module name for tests outside models.py
TEST_MODULE = 'tests'

doctestOutputChecker = OutputChecker()


def get_tests(app_module):
  try:
    app_path = app_module.__name__.split('.')[:-1]
    test_module = __import__('.'.join(app_path + [TEST_MODULE]), {}, {}, TEST_MODULE)
  except ImportError, e:
    # Couldn't import tests.py. Was it due to a missing file, or
    # due to an import error in a tests.py that actually exists?
    import os.path
    from imp import find_module
    try:
      mod = find_module(TEST_MODULE, [os.path.dirname(app_module.__file__)])
    except ImportError:
      # 'tests' module doesn't exist. Move on.
      test_module = None
    else:
      # The module exists, so there must be an import error in the
      # test module itself. We don't need the module; so if the
      # module was a single file module (i.e., tests.py), close the file
      # handle returned by find_module. Otherwise, the test module
      # is a directory, and there is nothing to close.
      if mod[0]:
          mod[0].close()
      raise
  return test_module


def get_multi_tests(app_module):
  import os
  def filename(module):
    return os.path.splitext(os.path.basename(module.__file__))[0]
  def extract_modules1(basepath, package):
    return [
      __import__('.'.join(app_path + [TEST_MODULE] + mod.split('.')[:-1]), {}, {}, mod.split('.')[-1])
      for mod in
      os.listdir(os.path.dirname(package.__file__))
      if (mod.startswith('test_') and mod.endswith('.py'))
      or os.path.isdir(mod)
      and not mod == '__init__.py'
    ]
  try:
    app_path = app_module.__name__.split('.')[:-1]
    test_module = __import__('.'.join(app_path + [TEST_MODULE]), {}, {}, TEST_MODULE)
    test_modules = []
    def extract_modules(package, prefix):
      for imp, name, ispkg in pkgutil.walk_packages(package, prefix):
        mod = __import__(name, fromlist=[''])
        if ispkg:
          extract_modules(mod.__path__, name+'.')
        elif mod not in test_modules:
          test_modules.append(mod)
    extract_modules(test_module.__path__, app_path[-1] + '.' + TEST_MODULE + '.')
    return test_modules or [test_module]
  except ImportError, e:
    return []


def build_suite(app_module):
  "Create a complete Django test suite for the provided application module"
  suite = unittest.TestSuite()

  # Load unit and doctests in the models.py module. If module has
  # a suite() method, use it. Otherwise build the test suite ourselves.
  if hasattr(app_module, 'suite'):
    suite.addTest(app_module.suite())
  else:
    suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(app_module))
    try:
      suite.addTest(doctest.DocTestSuite(app_module,
                                          checker=doctestOutputChecker,
                                          runner=DocTestRunner))
    except ValueError:
      # No doc tests in models.py
      pass

  # Check to see if a separate 'tests' module exists parallel to the
  # models module
  test_modules = get_multi_tests(app_module)
  if test_modules:
    for test_module in test_modules:
      # Load unit and doctests in the tests.py module. If module has
      # a suite() method, use it. Otherwise build the test suite ourselves.
      if hasattr(test_module, 'suite'):
        suite.addTest(test_module.suite())
      else:
        suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(test_module))
        try:
          suite.addTest(doctest.DocTestSuite(test_module,
                                            checker=doctestOutputChecker,
                                            runner=DocTestRunner))
        except ValueError:
          # No doc tests in tests.py
          pass
  else:
    test_module = get_tests(app_module)
    if test_module:
      # Load unit and doctests in the tests.py module. If module has
      # a suite() method, use it. Otherwise build the test suite ourselves.
      if hasattr(test_module, 'suite'):
        suite.addTest(test_module.suite())
      else:
        suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(test_module))
        try:
          suite.addTest(doctest.DocTestSuite(test_module,
                                            checker=doctestOutputChecker,
                                            runner=DocTestRunner))
        except ValueError:
          # No doc tests in tests.py
          pass
  return suite


def build_tests(label):
  """
  Construct a test case a test with the specified label. Label should
  be of the form model.TestClass, model.TestClass.test_method, or a import
  path to a test class. Returns an instantiated test or test suite
  corresponding to the label provided.
  """
  parts = label.split('.')
  if len(parts) < 2 or len(parts) > 3:
    raise ValueError("Test label '%s' should be of the form app.TestCase or app.TestCase.test_method" % label)

  app_module = get_app(parts[0])
  TestClasses = []
  TestClass = getattr(app_module, parts[1], None)

  # Couldn't find the test class in models.py; look in tests.py
  if TestClass is None:
    test_modules = get_multi_tests(app_module)
    if test_modules:
      for test_module in test_modules:
        if hasattr(test_module, parts[1]):
          TestClasses.append(getattr(test_module, parts[1], None))
          break
    else:
      test_module = get_tests(app_module)
      if test_module:
        TestClass = getattr(test_module, parts[1], None)
        if TestClass:
          TestClasses.append(TestClass)
  else:
    TestClasses.append(TestClass)

  if len(parts) == 2: # label is app.TestClass
    try:
      return [unittest.TestLoader().loadTestsFromTestCase(TestClass) for TestClass in TestClasses]
    except TypeError, e:
      raise ValueError("Test label '%s' does not refer to a test class" % label)
  else: # label is app.TestClass.test_method
    TestClasses = [t for t in TestClasses if hasattr(t, parts[2])]
    if not TestClasses:
      raise ValueError("Test label '%s' does not refer to a test class" % label)
    return [TestClass(parts[2]) for TestClass in TestClasses]


def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
  """
  Run the unit tests for all the test labels in the provided list.
  Labels must be of the form:
    - app.TestClass.test_method
      Run a single specific test method
    - app.TestClass
      Run all the test methods in a given class
    - app
      Search for doctests and unittests in the named application.

  When looking for tests, the test runner will look in the models and
  tests modules for the application, and will also check for
  tests.test_* modules to load tests from.

  A list of 'extra' tests may also be provided; these tests
  will be added to the test suite.

  Returns the number of tests that failed.
  """
  setup_test_environment()

  settings.DEBUG = False
  suite = unittest.TestSuite()

  if test_labels:
    for label in test_labels:
      if '.' in label:
        suite.addTests(build_tests(label))
      else:
        app = get_app(label)
        suite.addTest(build_suite(app))
  else:
    for app in get_apps():
      suite.addTest(build_suite(app))

  for test in extra_tests:
    suite.addTest(test)

  old_name = settings.DATABASE_NAME
  from django.db import connection
  connection.creation.create_test_db(verbosity, autoclobber=not interactive)
  result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
  connection.creation.destroy_test_db(old_name, verbosity)

  teardown_test_environment()

  return len(result.failures) + len(result.errors)

More like this

  1. Template tag - list punctuation for a list of items by shapiromatron 2 months, 2 weeks ago
  2. JSONRequestMiddleware adds a .json() method to your HttpRequests by cdcarter 2 months, 3 weeks ago
  3. Serializer factory with Django Rest Framework by julio 9 months, 2 weeks ago
  4. Image compression before saving the new model / work with JPG, PNG by Schleidens 10 months, 1 week ago
  5. Help text hyperlinks by sa2812 11 months ago

Comments

Please login first before commenting.