def _django_db_fixture_helper(transactional, request, _django_cursor_wrapper):
if is_django_unittest(request.node):
return
if transactional:
_django_cursor_wrapper.enable()
def flushdb():
"""Flush the database and close database connections"""
# Django does this by default *before* each test
# instead of after.
from django.db import connections
from django.core.management import call_command
for db in connections:
call_command('flush', verbosity=0,
interactive=False, database=db)
for conn in connections.all():
conn.close()
request.addfinalizer(_django_cursor_wrapper.disable)
request.addfinalizer(flushdb)
else:
if 'live_server' in request.funcargnames:
return
from django.test import TestCase
_django_cursor_wrapper.enable()
_django_cursor_wrapper._is_transactional = False
case = TestCase(methodName='__init__')
case._pre_setup()
request.addfinalizer(_django_cursor_wrapper.disable)
request.addfinalizer(case._post_teardown)
def run_test(test: TestCase, result: TestResult) -> bool:
failed = False
test_method = get_test_method(test)
if fast_tests_only() and is_known_slow_test(test_method):
return failed
test_name = full_test_name(test)
bounce_key_prefix_for_testing(test_name)
bounce_redis_key_prefix_for_testing(test_name)
flush_caches_for_testing()
if not hasattr(test, "_pre_setup"):
msg = "Test doesn't have _pre_setup; something is wrong."
error_pre_setup = (Exception, Exception(msg), None
) # type: Tuple[Any, Any, Any]
result.addError(test, error_pre_setup)
return True
test._pre_setup()
start_time = time.time()
test(result) # unittest will handle skipping, error, failure and success.
delay = time.time() - start_time
enforce_timely_test_completion(test_method, test_name, delay, result)
slowness_reason = getattr(test_method, 'slowness_reason', '')
TEST_TIMINGS.append((delay, test_name, slowness_reason))
test._post_teardown()
return failed
def run_test(test: TestCase, result: TestResult) -> bool:
failed = False
test_method = get_test_method(test)
if fast_tests_only() and is_known_slow_test(test_method):
return failed
test_name = full_test_name(test)
bounce_key_prefix_for_testing(test_name)
bounce_redis_key_prefix_for_testing(test_name)
flush_caches_for_testing()
if not hasattr(test, "_pre_setup"):
msg = "Test doesn't have _pre_setup; something is wrong."
error_pre_setup = (Exception, Exception(msg), None) # type: Tuple[Any, Any, Any]
result.addError(test, error_pre_setup)
return True
test._pre_setup()
start_time = time.time()
test(result) # unittest will handle skipping, error, failure and success.
delay = time.time() - start_time
enforce_timely_test_completion(test_method, test_name, delay, result)
slowness_reason = getattr(test_method, 'slowness_reason', '')
TEST_TIMINGS.append((delay, test_name, slowness_reason))
test._post_teardown()
return failed
def run_test(test: TestCase, result: TestResult) -> bool:
failed = False
test_method = get_test_method(test)
if fast_tests_only() and is_known_slow_test(test_method):
return failed
test_name = full_test_name(test)
bounce_key_prefix_for_testing(test_name)
bounce_redis_key_prefix_for_testing(test_name)
try:
test._pre_setup()
except Exception:
result.addError(test, sys.exc_info())
return True
start_time = time.time()
test(result) # unittest will handle skipping, error, failure and success.
delay = time.time() - start_time
enforce_timely_test_completion(test_method, test_name, delay, result)
slowness_reason = getattr(test_method, 'slowness_reason', '')
TEST_TIMINGS.append((delay, test_name, slowness_reason))
test._post_teardown()
return failed
def _pre_setup(self):
from film20.middleware import threadlocals
self.__class__._created_models = []
signals.post_save.connect(self._model_postsave)
logger.info("running test %r", self.id())
threadlocals._thread_locals.request = None
DjangoTestCase._pre_setup(self)
def _pre_setup(self):
from film20.middleware import threadlocals
self.__class__._created_models = []
signals.post_save.connect(self._model_postsave)
logger.info("running test %r", self.id())
threadlocals._thread_locals.request = None
if settings.USE_REDIS:
from film20.utils import redis_intf
redis_intf.redis.flushdb()
if hasattr(cache.cache, 'clear'):
cache.cache.clear()
DjangoTestCase._pre_setup(self)
def _pre_setup(self):
from film20.middleware import threadlocals
self.__class__._created_models = []
signals.post_save.connect(self._model_postsave)
logger.info("running test %r", self.id())
threadlocals._thread_locals.request = None
if settings.USE_REDIS:
from film20.utils import redis_intf
redis_intf.redis.flushdb()
if hasattr(cache.cache, 'clear'):
cache.cache.clear()
DjangoTestCase._pre_setup(self)
def run_test(test: TestCase, result: TestResult) -> bool:
failed = False
test_method = get_test_method(test)
if fast_tests_only() and is_known_slow_test(test_method):
return failed
test_name = full_test_name(test)
bounce_key_prefix_for_testing(test_name)
bounce_redis_key_prefix_for_testing(test_name)
flush_caches_for_testing()
if not hasattr(test, "_pre_setup"):
# We are supposed to get here only when running a single test suite
# on Python 3.5 or higher (the old import failure prefix is being
# checked just in case). When running several test suites at once,
# all import failures should be caught in deserialize_suite.
import_failure_prefix_old = 'unittest.loader.ModuleImportFailure.'
import_failure_prefix_new = 'unittest.loader._FailedTest.'
if test_name.startswith(import_failure_prefix_old):
actual_test_name = test_name[len(import_failure_prefix_old):]
raise TestSuiteImportError(test_name=actual_test_name)
elif test_name.startswith(import_failure_prefix_new):
actual_test_name = test_name[len(import_failure_prefix_new):]
raise TestSuiteImportError(test_name=actual_test_name)
else:
msg = "Test doesn't have _pre_setup; something is wrong."
error_pre_setup = (Exception, Exception(msg), None) # type: Tuple[Any, Any, Any]
result.addError(test, error_pre_setup)
return True
test._pre_setup()
start_time = time.time()
test(result) # unittest will handle skipping, error, failure and success.
delay = time.time() - start_time
enforce_timely_test_completion(test_method, test_name, delay, result)
slowness_reason = getattr(test_method, 'slowness_reason', '')
TEST_TIMINGS.append((delay, test_name, slowness_reason))
test._post_teardown()
return failed
def db(request, _django_db_setup, _django_cursor_wrapper):
"""Require a django test database
This database will be setup with the default fixtures and will
have the transaction management disabled. At the end of the test
the transaction will be rolled back to undo any changes to the
database. This is more limited then the ``transaction_db``
resource but faster.
If both this and ``transaction_db`` are requested then the
database setup will behave as only ``transaction_db`` was
requested.
"""
if ('transactional_db' not in request.funcargnames and
'live_server' not in request.funcargnames and
not is_django_unittest(request.node)):
from django.test import TestCase
_django_cursor_wrapper.enable()
case = TestCase(methodName='__init__')
case._pre_setup()
request.addfinalizer(case._post_teardown)
request.addfinalizer(_django_cursor_wrapper.disable)
def run_test(test: TestCase, result: TestResult) -> bool:
failed = False
test_method = get_test_method(test)
if fast_tests_only() and is_known_slow_test(test_method):
return failed
test_name = full_test_name(test)
bounce_key_prefix_for_testing(test_name)
bounce_redis_key_prefix_for_testing(test_name)
flush_caches_for_testing()
if not hasattr(test, "_pre_setup"):
# test_name is likely of the form unittest.loader.ModuleImportFailure.zerver.tests.test_upload
import_failure_prefix = 'unittest.loader.ModuleImportFailure.'
if test_name.startswith(import_failure_prefix):
actual_test_name = test_name[len(import_failure_prefix):]
error_msg = ("\nActual test to be run is %s, but import failed.\n"
"Importing test module directly to generate clearer "
"traceback:\n") % (actual_test_name, )
result.addInfo(test, error_msg)
try:
command = [
sys.executable, "-c",
"import %s" % (actual_test_name, )
]
msg = "Import test command: `%s`" % (' '.join(command), )
result.addInfo(test, msg)
subprocess.check_call(command)
except subprocess.CalledProcessError:
msg = ("If that traceback is confusing, try doing the "
"import inside `./manage.py shell`")
result.addInfo(test, msg)
result.addError(test, sys.exc_info())
return True
msg = ("Import unexpectedly succeeded! Something is wrong. Try "
"running `import %s` inside `./manage.py shell`.\n"
"If that works, you may have introduced an import "
"cycle.") % (actual_test_name, )
import_error = (Exception, Exception(msg), None
) # type: Tuple[Any, Any, Any]
result.addError(test, import_error)
return True
else:
msg = "Test doesn't have _pre_setup; something is wrong."
error_pre_setup = (Exception, Exception(msg), None
) # type: Tuple[Any, Any, Any]
result.addError(test, error_pre_setup)
return True
test._pre_setup()
start_time = time.time()
test(result) # unittest will handle skipping, error, failure and success.
delay = time.time() - start_time
enforce_timely_test_completion(test_method, test_name, delay, result)
slowness_reason = getattr(test_method, 'slowness_reason', '')
TEST_TIMINGS.append((delay, test_name, slowness_reason))
test._post_teardown()
return failed
def _db_helper(request: Any, django_db_blocker: Any) -> None:
django_db_blocker.unblock()
test_case = TestCase(methodName="__init__")
test_case._pre_setup()
request.addfinalizer(django_db_blocker.restore)
request.addfinalizer(test_case._post_teardown)