def setUp(self):
self.old_staticfiles_url = settings.STATICFILES_URL
self.old_staticfiles_root = settings.STATICFILES_ROOT
self.old_staticfiles_dirs = settings.STATICFILES_DIRS
self.old_staticfiles_finders = settings.STATICFILES_FINDERS
self.old_installed_apps = settings.INSTALLED_APPS
self.old_media_root = settings.MEDIA_ROOT
self.old_media_url = settings.MEDIA_URL
self.old_admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
self.old_debug = settings.DEBUG
# We have to load these apps to test staticfiles.
load_app('regressiontests.staticfiles_tests.apps.test')
load_app('regressiontests.staticfiles_tests.apps.no_label')
site_media = os.path.join(TEST_ROOT, 'project', 'site_media')
settings.DEBUG = True
settings.MEDIA_ROOT = os.path.join(site_media, 'media')
settings.MEDIA_URL = '/media/'
settings.STATICFILES_ROOT = os.path.join(site_media, 'static')
settings.STATICFILES_URL = '/static/'
settings.ADMIN_MEDIA_PREFIX = '/static/admin/'
settings.STATICFILES_DIRS = (
os.path.join(TEST_ROOT, 'project', 'documents'),
)
settings.STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
'django.contrib.staticfiles.finders.DefaultStorageFinder',
)
def setUp(self):
# Trick to be able to use test templates (inspired from django.contrib.auth.tests.views.ChangePasswordTest)
self.old_TEMPLATE_DIRS = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),'templates'),)
# Trick to dynamically install a test-specific app (until ticket #7835 get checked in: http://code.djangoproject.com/ticket/7835)
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = (
'imageutil',
'imageutil.tests.testapp',
)
load_app('imageutil.tests.testapp')
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
# since django's r11862 templatags_modules and app_template_dirs are cached
# the cache is not emptied between tests
# clear out the cache of modules to load templatetags from so it gets refreshed
template.templatetags_modules = []
# clear out the cache of app_directories to load templates from so it gets refreshed
app_directories.app_template_dirs = []
# reload the module to refresh the cache
reload(app_directories)
# Load test fixtures
self.old_FIXTURE_DIRS = settings.FIXTURE_DIRS
settings.FIXTURE_DIRS = (os.path.join(os.path.dirname(__file__), 'fixtures'),)
call_command('loaddata', 'iwh.json', verbosity=0, interactive=False)
def include_enabled_extensions(settings):
"""
This adds enabled extensions to the INSTALLED_APPS cache
so that operations like syncdb and evolve will take extensions
into consideration.
"""
# Some of our checks require access to django.conf.settings, so
# tell Django about our settings.
#
# This must go before the imports.
setup_environ(settings)
from django.db.models.loading import load_app
from django.db import DatabaseError
from reviewboard.extensions.base import get_extension_manager
try:
manager = get_extension_manager()
manager.load()
except DatabaseError:
# This database is from a time before extensions, so don't attempt to
# load any extensions yet.
return
for extension in manager.get_enabled_extensions():
load_app(extension.info.app_name)
def include_enabled_extensions(settings):
"""
This adds enabled extensions to the INSTALLED_APPS cache
so that operations like syncdb and evolve will take extensions
into consideration.
"""
# Some of our checks require access to django.conf.settings, so
# tell Django about our settings.
#
# This must go before the imports.
setup_environ(settings)
from django.db.models.loading import load_app
from django.db import DatabaseError
from reviewboard.extensions.base import get_extension_manager
try:
manager = get_extension_manager()
manager.load()
except DatabaseError:
# This database is from a time before extensions, so don't attempt to
# load any extensions yet.
return
for extension in manager.get_enabled_extensions():
load_app(extension.info.app_name)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
apps.register_model(app_config.label, value)
call_command('migrate', verbosity=0, interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
if models_mod:
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
apps.register_model(app_config.label, value)
call_command('migrate', verbosity=0, interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def setUp(self):
# Install testapp
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ['holdingpage.tests.testapp']
load_app('testapp')
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
# Tweak settings
if hasattr(settings, 'HOLDINGPAGE_ACTIVATED'):
self.old_HOLDINGPAGE_ACTIVATED = settings.HOLDINGPAGE_ACTIVATED
if 'holdingpage.middleware.HoldingPageMiddleware' not in settings.MIDDLEWARE_CLASSES:
self.old_MIDDLEWARE_CLASSES = settings.MIDDLEWARE_CLASSES
settings.MIDDLEWARE_CLASSES = list(settings.MIDDLEWARE_CLASSES) + ['holdingpage.middleware.HoldingPageMiddleware']
if hasattr(settings, 'HOLDINGPAGE_ALLOWED_URL_PATTERNS'):
self.old_HOLDINGPAGE_ALLOWED_URL_PATTERNS = settings.HOLDINGPAGE_ALLOWED_URL_PATTERNS
settings.HOLDINGPAGE_ALLOWED_URL_PATTERNS = ['^/a_path/$']
if hasattr(settings, 'HOLDINGPAGE_ALLOWED_VIEWS'):
self.old_HOLDINGPAGE_ALLOWED_VIEWS = settings.HOLDINGPAGE_ALLOWED_VIEWS
settings.HOLDINGPAGE_ALLOWED_VIEWS = ['holdingpage.tests.testapp.views.a_view']
if hasattr(settings, 'HOLDINGPAGE_URL'):
self.HOLDINGPAGE_URL = settings.HOLDINGPAGE_URL
settings.HOLDINGPAGE_URL = '/holding-test/'
# Initial Data
self.notstaff_user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
self.staff_user = User.objects.create_user(username='******', email='*****@*****.**', password='******')
self.staff_user.is_staff = True
self.staff_user.save()
def setUp(self):
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ('workflow.tests.fakeapp', )
load_app('workflow.tests.fakeapp')
loading.cache.loaded = False
call_command('syncdb', verbosity=0,
interactive=False) #Create tables for fakeapp
def setUp(self):
print ">", settings.INSTALLED_APPS
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ( 'utils.tests.fakeapp', )
loading.cache.loaded = False
load_app('utils.tests.fakeapp')
call_command('syncdb', verbosity=0, interactive=False) # Create tables for fakeapp
def setUp(self):
self.__class__.__module__ = self.__class__.__name__
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += [APP_NAME]
load_app(APP_NAME)
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
def setUp(self):
self.__class__.__module__ = self.__class__.__name__
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += [APP_NAME]
load_app(APP_NAME)
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
def _setUp_test_app(self):
app_name = 'method_cache.tests.mcthings'
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = settings.INSTALLED_APPS + [app_name]
load_app(app_name)
call_command('syncdb', verbosity=0, interactive=False)
def _setUp_test_app(self):
app_name = 'method_cache.tests.mcthings'
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = settings.INSTALLED_APPS + [app_name]
load_app(app_name)
call_command('syncdb', verbosity=0, interactive=False)
def setUp(self):
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = (
'usertools',
'usertools.tests.test_app',
)
load_app('usertools.tests.test_app')
call_command('syncdb', verbosity=0, interactive=False)
def install():
import os, sys
current_folder = os.path.dirname(__file__)
sys.path.append(os.path.join(current_folder, 'libs'))
from django.conf import settings
settings.INSTALLED_APPS += ('cartoview.apps.cartoview_arcgis_feature_server.cartoserver',)
from django.db.models.loading import load_app
load_app('cartoview.apps.cartoview_arcgis_feature_server.cartoserver')
def install():
import os, sys
current_folder = os.path.dirname(__file__)
sys.path.append(os.path.join(current_folder, 'libs'))
from django.conf import settings
settings.INSTALLED_APPS += (
'cartoview.apps.cartoview_arcgis_feature_server.cartoserver', )
from django.db.models.loading import load_app
load_app('cartoview.apps.cartoview_arcgis_feature_server.cartoserver')
def setUp(self):
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = (tuple(settings.INSTALLED_APPS) +
self.test_apps)
for app in self.test_apps:
load_app(app)
if self.test_apps:
# Create tables for any test-only applications.
call_command('syncdb', verbosity=0, interactive=False)
def add_test_apps(test_apps):
from django.db.models.loading import load_app
from django.core.management import call_command
original_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + tuple(test_apps)
for test_app in test_apps:
load_app(test_app)
call_command('syncdb', verbosity=0, interactive=False)
return original_INSTALLED_APPS
def setUp(self):
self.maxDiff = None
print ">>", settings.INSTALLED_APPS
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ('utils.tests.fakeapp', )
loading.cache.loaded = False
load_app('utils.tests.fakeapp')
call_command('syncdb', verbosity=0,
interactive=False) # Create tables for fakeapp
def post_environ(self):
'''
Call this method once django environ has been setup. This will tell the
plugins it's time to complete with the setup process.
'''
from django.db.models.loading import load_app
for plugin in self.get_plugins():
if plugin.provides.get('post_environ', False):
plugin.module.post_environ()
for plugin in self.get_plugins():
load_app(plugin.name)
def test_egg5(self):
"""Loading an app from an egg that has an import error in its models module raises that error"""
egg_name = '%s/brokenapp.egg' % self.egg_dir
sys.path.append(egg_name)
self.assertRaises(ImportError, load_app, 'broken_app')
try:
load_app('broken_app')
except ImportError as e:
# Make sure the message is indicating the actual
# problem in the broken app.
self.assertTrue("modelz" in e.args[0])
def post_environ(self):
'''
Call this method once django environ has been setup. This will tell the
plugins it's time to complete with the setup process.
'''
from django.db.models.loading import load_app
for plugin in self.get_plugins():
if plugin.provides.get('post_environ', False):
plugin.module.post_environ()
for plugin in self.get_plugins():
load_app(plugin.name)
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = 'suit.tests'
settings.INSTALLED_APPS = tuple(
list(self.saved_INSTALLED_APPS) + [test_app])
settings.DEBUG = True
# load our fake application and syncdb
load_app(test_app)
call_command('syncdb', verbosity=0, interactive=False)
super(ModelsTestCaseMixin, self)._pre_setup()
def test_egg5(self):
"""Loading an app from an egg that has an import error in its models module raises that error"""
egg_name = '%s/brokenapp.egg' % self.egg_dir
sys.path.append(egg_name)
self.assertRaises(ImportError, load_app, 'broken_app')
try:
load_app('broken_app')
except ImportError, e:
# Make sure the message is indicating the actual
# problem in the broken app.
self.assertTrue("modelz" in e.args[0])
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = 'suit.tests'
settings.INSTALLED_APPS = tuple(
list(self.saved_INSTALLED_APPS) + [test_app]
)
settings.DEBUG = True
# load our fake application and syncdb
load_app(test_app)
call_command('syncdb', verbosity=0, interactive=False)
super(ModelsTestCaseMixin, self)._pre_setup()
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = 'merge.tests.testapp'
settings.INSTALLED_APPS = tuple(
list(self.saved_INSTALLED_APPS) + [test_app]
)
settings.DEBUG = True
# load our fake application and syncdb
load_app(test_app)
call_command('syncdb', verbosity=0, interactive=False)
super(MergeSourceTests, self)._pre_setup()
def read(self, request):
from django.db.models.loading import load_app
errors = []
for app in settings.INSTALLED_APPS:
try:
load_app(app)
except Exception as e:
errors.append({app: ("Can't load application {0}. Error was {1}").format(app, e)})
if errors:
return {"status": "error", "errors": errors}
return {"status": "ok"}
def setUpClass(cls):
# Modify sys path
cls.old_sys_path = sys.path[:]
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
# Change settings, we can't use decorator that would change settings too late for us.
cls.override = override_settings(LANGUAGE_CODE='cs', LANGUAGES=TEST_LANGUAGES,
INSTALLED_APPS=list(settings.INSTALLED_APPS) + ['ml_test_app'])
cls.override.enable()
# Install test app
load_app('ml_test_app')
call_command('syncdb', verbosity=0)
def setUp(self):
# Install testapp
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ['treemenus.tests.fake_menu_extension']
load_app('fake_menu_extension')
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
# Log in as admin
User.objects.create_superuser('super', '*****@*****.**', 'secret')
login = self.client.login(username='******', password='******')
self.assertEqual(login, True)
def handle_label(self, label, **options):
platform_app = None
logger = self._get_logger()
logger.debug('attempting to import app: %s', label)
try:
load_app(label)
except ImportError:
logger.debug("could not import custom backend '%s'", label)
else:
platform_app = label
if not platform_app:
logger.debug('trying to import from parachute default apps')
# import the correct app for the desired backend
label = "%s.%s" % (self.import_app, label)
try:
load_app(label)
except ImportError:
logger.error("invalid import backend '%s' specified", label)
return
else:
platform_app = label
logger.info("succesfully loaded importer app for '%s'", platform_app)
try:
backend = __import__(platform_app, globals(), locals(), ['Importer'])
importer = backend.Importer(
app_name=label.split('.')[-1],
force_update=options.get('force_update', False),
verbosity=int(options.get('verbosity', logging.INFO)),
)
except AttributeError:
logger.error("no importer available in backend '%s'", platform_app)
return
logger.debug("found importer object for '%s'", platform_app)
importer.prepare_import(**options)
if options.get('import_customers'):
importer.import_customers()
if options.get('import_catalogue'):
importer.import_catalogue()
if options.get('import_orders'):
importer.import_orders()
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = "johnny.tests.testapp"
settings.INSTALLED_APPS = tuple(list(self.saved_INSTALLED_APPS) + [test_app])
settings.DEBUG = True
# load our fake application and syncdb
load_app(test_app)
call_command("syncdb", verbosity=0, interactive=False)
if hasattr(settings, "DATABASES"):
for dbname in settings.DATABASES:
if dbname != "default":
call_command("syncdb", verbosity=0, interactive=False, database=dbname)
def _pre_setup(self):
#add BackupTestWidget model
self.old_installed_apps = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ['vz_backup.tests.testwidgets']
loading.cache.loaded = False
loading.load_app('vz_backup.tests.testwidgets')
call_command('syncdb', verbosity=0, interactive=False)
#create a temp directory for backup archives
self.old_backup_dir = settings.VZ_BACKUP_DIR
settings.VZ_BACKUP_DIR = tempfile.mkdtemp()
super(BackupTestCase, self)._pre_setup()
def install_app(app_name):
from django.conf import settings
settings.INSTALLED_APPS.append ('apps.%s' % app_name)
from django.db.models.loading import load_app
load_app('apps.%s' % app_name)
from django.core.management import call_command
call_command('syncdb',load_initial_data=False)
try:
print os.path.join(APPS_DIR,app_name,'fixtures')
call_command('loaddata', os.path.join(APPS_DIR,app_name,'fixtures','initial_data.json'))
except Exception:
pass
from cartoview2.urls import register_app_urls
register_app_urls(app_name)
def setUp(self):
self.installed_apps = settings.INSTALLED_APPS
settings.INSTALLED_APPS.append('cuddlybuddly.thumbnail.tests.cbtfakeapp')
try:
FakeImage.objects.count()
except:
load_app('cuddlybuddly.thumbnail.tests.cbtfakeapp')
# Another try/except is needed because contrib.auth will sometimes
# fail to create the permissions when some other third app is also
# loaded.
try:
# Don't use call_command because if South is installed it
# overrides syncdb and unnecessary warnings are printed out
# during tests.
from django.core.management.commands import syncdb
syncdb.Command().handle_noargs(verbosity=0, interactive=False)
except:
pass
self.images_to_delete = set()
self.cache_to_delete = set()
file = StringIO()
Image.new('RGB', PIC_SIZE).save(file, 'JPEG')
default_storage.save(PIC_NAME, ContentFile(file.getvalue()))
self.images_to_delete.add(PIC_NAME)
file.close()
self.MEDIA_MIDDLE = os.path.join(
getattr(settings, 'CUDDLYBUDDLY_THUMBNAIL_BASEDIR', ''),
getattr(settings, 'CUDDLYBUDDLY_THUMBNAIL_SUBDIR', ''),
)
self.cache_backup = getattr(settings, 'CUDDLYBUDDLY_THUMBNAIL_CACHE', None)
if not self.cache_backup:
settings.CUDDLYBUDDLY_THUMBNAIL_CACHE = CACHE_DIR
self.delete_cache_dir = False
if self.cache_backup is None:
if not os.path.exists(CACHE_DIR):
self.delete_cache_dir = True
cache = os.path.join(
settings.CUDDLYBUDDLY_THUMBNAIL_CACHE,
md5_constructor(smart_str(RELATIVE_PIC_NAME)).hexdigest()
)
self.cache_to_delete.add(cache)
self.old_processors = thumbnail.PROCESSORS
self.old_default_processor = thumbnail.DEFAULT_PROCESSOR
thumbnail.PROCESSORS = {
'crop': CropToFitProcessor,
'resize': ResizeProcessor
}
thumbnail.DEFAULT_PROCESSOR = ResizeProcessor
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = 'johnny.tests.testapp'
settings.INSTALLED_APPS = tuple(
list(self.saved_INSTALLED_APPS) + [test_app]
)
settings.DEBUG = True
# load our fake application and syncdb
load_app(test_app)
call_command('syncdb', verbosity=0, interactive=False)
if hasattr(settings, 'DATABASES'):
for dbname in settings.DATABASES:
if dbname != 'default':
call_command('syncdb', verbosity=0, interactive=False, database=dbname)
def install_app(app_name):
from django.conf import settings
settings.INSTALLED_APPS += (app_name,)
from django.db.models.loading import load_app
load_app(app_name)
from django.core.management import call_command
call_command('syncdb', load_initial_data=False)
call_command('collectstatic', interactive=False)
try:
print os.path.join(settings.APPS_DIR, app_name, 'fixtures')
call_command('loaddata', os.path.join(settings.APPS_DIR, app_name, 'fixtures', 'initial_data.json'))
except Exception:
pass
# from urls import register_app_urls
register_app_urls(app_name)
def prepareTestRunner(self, test):
cur_stdout = sys.stdout
cur_stderr = sys.stderr
sys.stdout = self.sys_stdout
sys.stderr = self.sys_stderr
if self.add_apps:
for app in self.add_apps:
if app in settings.INSTALLED_APPS:
continue
mod = load_app(app)
if mod:
settings.INSTALLED_APPS.append(app)
get_apps()
self.runner.setup_test_environment()
if self.needs_db:
self.old_names = self.runner.setup_databases()
sys.stdout = cur_stdout
sys.stderr = cur_stderr
self.started = True
def setup(verbosity, test_labels):
from django.conf import settings
state = {
'INSTALLED_APPS': settings.INSTALLED_APPS,
'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""),
'TEMPLATE_DIRS': settings.TEMPLATE_DIRS,
'USE_I18N': settings.USE_I18N,
'LOGIN_URL': settings.LOGIN_URL,
'LANGUAGE_CODE': settings.LANGUAGE_CODE,
'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES,
'STATIC_URL': settings.STATIC_URL,
'STATIC_ROOT': settings.STATIC_ROOT,
}
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = 'urls'
settings.STATIC_URL = '/static/'
settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static')
settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR), )
settings.USE_I18N = True
settings.LANGUAGE_CODE = 'en'
settings.MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.common.CommonMiddleware',
)
settings.SITE_ID = 1
# For testing comment-utils, we require the MANAGERS attribute
# to be set, so that a test email is sent out which we catch
# in our tests.
settings.MANAGERS = ("*****@*****.**", )
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
django.setup()
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
test_labels_set = set([label.split('.')[0] for label in test_labels])
test_modules = get_test_modules()
for module_name in test_modules:
module_label = module_name
# if the module was named on the command line, or
# no modules were named (i.e., run all), import
# this module and add it to the list to test.
if not test_labels or module_name in test_labels_set:
if verbosity >= 2:
print "Importing application %s" % module_name
mod = load_app(module_label)
if mod:
if module_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(module_label)
return state
def create_models_from_app(cls, app_name):
"""
Manually create Models (used only for testing) from the specified string app name.
Models are loaded from the module '<app_name>.models'
"""
from django.db import connection, DatabaseError
from django.test.simple import DjangoTestSuiteRunner
# NB: `load_app` is deprecated as of Django 1.7.
if re.match(r'''^1\.7.*$''', django.get_version()) is not None:
from django.apps import apps
# NB: Django 1.7 doesn't work with the fully-qualified app name.
app = apps.get_app_config(app_name.split('.')[1])
else:
from django.db.models.loading import load_app
app = load_app(app_name)
from django.core.management import sql
from django.core.management.color import no_style
sql = sql.sql_create(app, no_style(), connection)
cursor = connection.cursor()
for statement in sql:
try:
cursor.execute(statement)
except DatabaseError, excn:
logger.debug(excn.message)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def setup(verbosity, test_labels):
from django.conf import settings
state = {
'INSTALLED_APPS': settings.INSTALLED_APPS,
'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""),
'TEMPLATE_DIRS': settings.TEMPLATE_DIRS,
'USE_I18N': settings.USE_I18N,
'LOGIN_URL': settings.LOGIN_URL,
'LANGUAGE_CODE': settings.LANGUAGE_CODE,
'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES,
'STATIC_URL': settings.STATIC_URL,
'STATIC_ROOT': settings.STATIC_ROOT,
}
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = 'urls'
settings.STATIC_URL = '/static/'
settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static')
settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR),)
settings.USE_I18N = True
settings.LANGUAGE_CODE = 'en'
settings.MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.common.CommonMiddleware',
)
settings.SITE_ID = 1
# For testing comment-utils, we require the MANAGERS attribute
# to be set, so that a test email is sent out which we catch
# in our tests.
settings.MANAGERS = ("*****@*****.**",)
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
django.setup()
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
test_labels_set = set([label.split('.')[0] for label in test_labels])
test_modules = get_test_modules()
for module_name in test_modules:
module_label = module_name
# if the module was named on the command line, or
# no modules were named (i.e., run all), import
# this module and add it to the list to test.
if not test_labels or module_name in test_labels_set:
if verbosity >= 2:
print "Importing application %s" % module_name
mod = load_app(module_label)
if mod:
if module_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(module_label)
return state
def django_tests(verbosity, interactive, failfast, test_labels):
from django.conf import settings
old_installed_apps = settings.INSTALLED_APPS
old_root_urlconf = getattr(settings, "ROOT_URLCONF", "")
old_template_dirs = settings.TEMPLATE_DIRS
old_use_i18n = settings.USE_I18N
old_login_url = settings.LOGIN_URL
old_language_code = settings.LANGUAGE_CODE
old_middleware_classes = settings.MIDDLEWARE_CLASSES
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
for model_dir, model_name in get_test_models():
model_label = '.'.join([model_dir, model_name])
try:
# if the model was named on the command line, or
# no models were named (i.e., run all), import
# this model and add it to the list to test.
if not test_labels or model_name in set([label.split('.')[0] for label in test_labels]):
if verbosity >= 1:
print "Importing model %s" % model_name
mod = load_app(model_label)
if mod:
if model_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(model_label)
except Exception, e:
sys.stderr.write("Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:]))
continue
def prepareTestRunner(self, test):
cur_stdout = sys.stdout
cur_stderr = sys.stderr
sys.stdout = self.sys_stdout
sys.stderr = self.sys_stderr
if self.add_apps:
for app in self.add_apps:
if app in settings.INSTALLED_APPS:
continue
mod = load_app(app)
if mod:
settings.INSTALLED_APPS.append(app)
get_apps()
self.runner.setup_test_environment()
if self.needs_db:
self.old_names = self.runner.setup_databases()
sys.stdout = cur_stdout
sys.stderr = cur_stderr
self.started = True
def runTest(self):
from django.core.management.validation import get_validation_errors
from django.db.models.loading import load_app
from io import StringIO
try:
module = load_app(self.model_label)
except Exception as e:
self.fail('Unable to load invalid model module')
# Make sure sys.stdout is not a tty so that we get errors without
# coloring attached (makes matching the results easier). We restore
# sys.stderr afterwards.
orig_stdout = sys.stdout
s = StringIO()
sys.stdout = s
count = get_validation_errors(s, module)
sys.stdout = orig_stdout
s.seek(0)
error_log = s.read()
actual = error_log.split('\n')
expected = module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertTrue(not unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
self.assertTrue(not missing, "Missing Errors: " + '\n'.join(missing))
def create_models_from_app(cls, app_name):
"""
Manually create Models (used only for testing) from the specified string app name.
Models are loaded from the module '<app_name>.models'
"""
from django.db import connection, DatabaseError
from django.test.simple import DjangoTestSuiteRunner
# NB: `load_app` is deprecated as of Django 1.7.
if re.match(r'''^1\.7.*$''', django.get_version()) is not None:
from django.apps import apps
# NB: Django 1.7 doesn't work with the fully-qualified app name.
app = apps.get_app_config(app_name.split('.')[1])
else:
from django.db.models.loading import load_app
app = load_app(app_name)
from django.core.management import sql
from django.core.management.color import no_style
sql = sql.sql_create(app, no_style(), connection)
cursor = connection.cursor()
for statement in sql:
try:
cursor.execute(statement)
except DatabaseError, excn:
logger.debug(excn.message)
def django_tests(verbosity, interactive, failfast, test_labels):
from django.conf import settings
old_installed_apps = settings.INSTALLED_APPS
old_root_urlconf = getattr(settings, "ROOT_URLCONF", "")
old_template_dirs = settings.TEMPLATE_DIRS
old_use_i18n = settings.USE_I18N
old_login_url = settings.LOGIN_URL
old_language_code = settings.LANGUAGE_CODE
old_middleware_classes = settings.MIDDLEWARE_CLASSES
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = 'urls'
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
TEST_TEMPLATE_DIR), )
settings.USE_I18N = True
settings.LANGUAGE_CODE = 'en'
settings.LOGIN_URL = '/accounts/login/'
settings.MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.common.CommonMiddleware',
)
settings.SITE_ID = 1
# For testing comment-utils, we require the MANAGERS attribute
# to be set, so that a test email is sent out which we catch
# in our tests.
settings.MANAGERS = ("*****@*****.**", )
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
for model_dir, model_name in get_test_models():
model_label = '.'.join([model_dir, model_name])
try:
# if the model was named on the command line, or
# no models were named (i.e., run all), import
# this model and add it to the list to test.
if not test_labels or model_name in set(
[label.split('.')[0] for label in test_labels]):
if verbosity >= 1:
print "Importing model %s" % model_name
mod = load_app(model_label)
if mod:
if model_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(model_label)
except Exception, e:
sys.stderr.write(
"Error while importing %s:" % model_name +
''.join(traceback.format_exception(*sys.exc_info())[1:]))
continue
def runTest(self):
from django.core.management.validation import get_validation_errors
from django.db.models.loading import load_app
from cStringIO import StringIO
try:
module = load_app(self.model_label)
except Exception, e:
self.fail('Unable to load invalid model module')
def install_app(app_name):
from django.conf import settings
settings.INSTALLED_APPS += (app_name, )
from django.db.models.loading import load_app
load_app(app_name)
from django.core.management import call_command
call_command('syncdb', load_initial_data=False)
call_command('collectstatic', interactive=False)
try:
print os.path.join(settings.APPS_DIR, app_name, 'fixtures')
call_command(
'loaddata',
os.path.join(settings.APPS_DIR, app_name, 'fixtures',
'initial_data.json'))
except Exception:
pass
# from urls import register_app_urls
register_app_urls(app_name)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
if models_mod:
app_label = app_config.label
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
# The model was likely registered under another app,
# so we need to remove the old one and add the new
# one.
try:
del apps.all_models[value._meta.app_label][
value._meta.model_name]
except KeyError:
pass
value._meta.app_label = app_label
apps.register_model(app_label, value)
call_command('migrate',
run_syncdb=True,
verbosity=0,
interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def _pre_setup(self):
self.saved_INSTALLED_APPS = settings.INSTALLED_APPS
self.saved_DEBUG = settings.DEBUG
test_app = 'suit.tests'
settings.INSTALLED_APPS = tuple(
list(self.saved_INSTALLED_APPS) + [test_app])
settings.DEBUG = True
# Legacy Django < 1.9: load our fake application and syncdb
try:
from django.db.models.loading import load_app
load_app(test_app)
except ImportError:
pass
try:
call_command('syncdb', verbosity=0, interactive=False)
except CommandError:
pass
super(ModelsTestCaseMixin, self)._pre_setup()
def include_enabled_extensions(settings):
"""
This adds enabled extensions to the INSTALLED_APPS cache
so that operations like syncdb and evolve will take extensions
into consideration.
"""
from django.db.models.loading import load_app
from django.db import DatabaseError
from reviewboard.extensions.base import get_extension_manager
try:
manager = get_extension_manager()
except DatabaseError:
# This database is from a time before extensions, so don't attempt to
# load any extensions yet.
return
for extension in manager.get_enabled_extensions():
load_app(extension.info.app_name)
def are_installed_models(app_name):
if have_south(app_name):
return False
app_module = load_app(get_plugin_module_name(app_name))
plugin_models = get_models(app_module)
tables = connection.introspection.table_names()
seen_models = connection.introspection.installed_models(tables)
for plugin_model in plugin_models:
if not plugin_model in seen_models:
return False
return True
def django_tests(verbosity, interactive, test_labels):
from django.conf import settings
import deseb
deseb.add_aka_support()
old_installed_apps = settings.INSTALLED_APPS
old_test_database_name = settings.TEST_DATABASE_NAME
old_root_urlconf = settings.ROOT_URLCONF
old_template_dirs = settings.TEMPLATE_DIRS
old_use_i18n = settings.USE_I18N
old_middleware_classes = settings.MIDDLEWARE_CLASSES
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = 'urls'
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
TEST_TEMPLATE_DIR), )
settings.USE_I18N = True
settings.MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.middleware.common.CommonMiddleware',
)
if not hasattr(settings, 'SITE_ID'):
settings.SITE_ID = 1
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
test_models = []
for model_dir, model_name in get_test_models():
model_label = '.'.join([model_dir, model_name])
try:
# if the model was named on the command line, or
# no models were named (i.e., run all), import
# this model and add it to the list to test.
if not test_labels or model_name in set(
[label.split('.')[0] for label in test_labels]):
if verbosity >= 1:
print "Importing model %s" % model_name
mod = load_app(model_label)
if mod:
if model_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(model_label)
except Exception, e:
sys.stderr.write(
"Error while importing %s:" % model_name +
''.join(traceback.format_exception(*sys.exc_info())[1:]))
continue
def setUp(self):
# Install testapp
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
settings.INSTALLED_APPS += ['treemenus.tests.fake_menu_extension']
load_app('treemenus.tests.fake_menu_extension')
call_command('syncdb', verbosity=0, interactive=False)
# since django's r11862 templatags_modules and app_template_dirs are cached
# the cache is not emptied between tests
# clear out the cache of modules to load templatetags from so it gets refreshed
template.templatetags_modules = []
# clear out the cache of app_directories to load templates from so it gets refreshed
app_directories.app_template_dirs = []
# reload the module to refresh the cache
reload(app_directories)
# Log in as admin
User.objects.create_superuser('super', '*****@*****.**', 'secret')
login = self.client.login(username='******', password='******')
self.assertEqual(login, True)
def setUp(self):
self.__class__.__module__ = self.__class__.__name__
self.old_INSTALLED_APPS = settings.INSTALLED_APPS
if isinstance(settings.INSTALLED_APPS, tuple):
settings.INSTALLED_APPS += (APP_NAME, )
else:
settings.INSTALLED_APPS += [APP_NAME]
self._old_root_urlconf = settings.ROOT_URLCONF
settings.ROOT_URLCONF = '%s.urls' % APP_NAME
load_app(APP_NAME)
call_command('flush', verbosity=0, interactive=False)
call_command('syncdb', verbosity=0, interactive=False)
self.ae = self.assertEqual
self._old_template_loaders = settings.TEMPLATE_LOADERS
loaders = list(settings.TEMPLATE_LOADERS)
try:
loaders.remove('django.template.loaders.filesystem.Loader')
settings.TEMPLATE_LOADERS = loaders
self._refresh_cache()
except ValueError:
pass
def setUp(self):
self.old_static_url = settings.STATIC_URL
self.old_static_root = settings.STATIC_ROOT
self.old_staticfiles_dirs = settings.STATICFILES_DIRS
self.old_staticfiles_finders = settings.STATICFILES_FINDERS
self.old_media_root = settings.MEDIA_ROOT
self.old_media_url = settings.MEDIA_URL
self.old_admin_media_prefix = settings.ADMIN_MEDIA_PREFIX
self.old_debug = settings.DEBUG
self.old_installed_apps = settings.INSTALLED_APPS
# We have to load these apps to test staticfiles.
load_app('regressiontests.staticfiles_tests.apps.test')
load_app('regressiontests.staticfiles_tests.apps.no_label')
site_media = os.path.join(TEST_ROOT, 'project', 'site_media')
settings.DEBUG = True
settings.MEDIA_ROOT = os.path.join(site_media, 'media')
settings.MEDIA_URL = '/media/'
settings.STATIC_ROOT = os.path.join(site_media, 'static')
settings.STATIC_URL = '/static/'
settings.ADMIN_MEDIA_PREFIX = '/static/admin/'
settings.STATICFILES_DIRS = (
os.path.join(TEST_ROOT, 'project', 'documents'),
)
settings.STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
'django.contrib.staticfiles.finders.DefaultStorageFinder',
)
settings.INSTALLED_APPS = [
"django.contrib.staticfiles",
"regressiontests.staticfiles_tests",
]
# Clear the cached default_storage out, this is because when it first
# gets accessed (by some other test), it evaluates settings.MEDIA_ROOT,
# since we're planning on changing that we need to clear out the cache.
default_storage._wrapped = None
def _create_test_models(cls, app_name='testapp'):
"""Create dynamic test models.
Defaulted to models registered at app_name.models.py
"""
app = loading.load_app(app_name)
create_sql = sql.sql_create(app, color.no_style(), connection)
cursor = connection.cursor()
for statement in create_sql:
try:
cursor.execute(statement)
except DatabaseError as ex:
LOGGER.debug(ex)
def add_fixtures(zip_config, plugin, plugin_path, plugin_path_zip):
"""
Backup fixtures into zip file
"""
from merengue.pluggable.utils import get_plugin_module_name
# next two sentences is for avoiding problems with zipfile module
# (encoding errors)
plugin_path = smart_str(plugin_path)
plugin_path_zip = smart_str(plugin_path_zip)
plugin_modname = get_plugin_module_name(plugin.directory_name)
plugin_mod = load_app(plugin_modname)
plugin_models = get_models(plugin_mod)
fixtures = get_fixtures(plugin_models)
format = 'xml'
fixtures_file = os.path.join(plugin_path_zip, "fixtures.%s" % format)
zip_config.writestr(fixtures_file, "\n".join(fixtures))
def test_invalid_models(self):
try:
module = load_app("invalid_models.invalid_models")
except Exception:
self.fail('Unable to load invalid model module')
get_validation_errors(self.stdout, module)
self.stdout.seek(0)
error_log = self.stdout.read()
actual = error_log.split('\n')
expected = module.model_errors.split('\n')
unexpected = [err for err in actual if err not in expected]
missing = [err for err in expected if err not in actual]
self.assertFalse(unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
self.assertFalse(missing, "Missing Errors: " + '\n'.join(missing))