def __init__(self, *args, **kwargs): self.configure() self.cov = coverage() self.cov.start() self.packages = self.resolve_packages() parser = argparse.ArgumentParser() parser.add_argument('-a', '--autoreload', dest='autoreload', action='store_const', const=True, default=False,) parser.add_argument('-f', '--failfast', dest='failfast', action='store_const', const=True, default=False,) parser.add_argument('-l', '--label', dest='label') self.options = vars(parser.parse_args(sys.argv[2:])) sys.argv = sys.argv[:2] super(SetupTestSuite, self).__init__(tests=self.build_tests(), *args, **kwargs) # Setup testrunner. from django.test.simple import DjangoTestSuiteRunner self.test_runner = DjangoTestSuiteRunner( verbosity=1, interactive=True, failfast=False ) # South patches the test management command to handle the # SOUTH_TESTS_MIGRATE setting. Apply that patch if South is installed. try: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except ImportError: pass self.test_runner.setup_test_environment() self.old_config = self.test_runner.setup_databases()
def main(): TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=2, failfast=False) if len(sys.argv) > 1: test_modules = sys.argv[1:] elif len(sys.argv) == 1: test_modules = [] else: print(usage()) sys.exit(1) if django.VERSION >= (1, 6, 0): # this is a compat hack because in django>=1.6.0 you must provide # module like "userena.contrib.umessages" not "umessages" test_modules = [ get_app(module_name).__name__[:-7] for module_name in test_modules ] if django.VERSION < (1, 7, 0): # starting from 1.7.0 built in django migrations are run # for older releases this patch is required to enable testing with # migrations from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() failures = test_runner.run_tests(test_modules or ['userena']) sys.exit(failures)
def handle(self, *fixture_labels, **options): from django.core.management import call_command from django.db import connection from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() verbosity = int(options.get('verbosity')) interactive = options.get('interactive') addrport = options.get('addrport') # Create a test database. db_name = connection.creation.create_test_db(verbosity=verbosity, autoclobber=not interactive) # Import the fixture data into the test database. call_command('loaddata', *fixture_labels, **{'verbosity': verbosity}) # Run the development server. Turn off auto-reloading because it causes # a strange error -- it causes this handle() method to be called # multiple times. shutdown_message = '\nServer stopped.\nNote that the test database, %r, has not been deleted. You can explore it on your own.' % db_name use_threading = connection.features.test_db_allows_multiple_connections call_command('runserver', addrport=addrport, shutdown_message=shutdown_message, use_reloader=False, use_ipv6=options['use_ipv6'], use_threading=use_threading )
def runtests(): from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = get_runner(settings) test_runner = test_runner(interactive=True, verbosity=1, failfast=False) failures = test_runner.run_tests([]) sys.exit(bool(failures))
def django_tests(verbosity, interactive, failfast, test_labels): import django from django.conf import settings if hasattr(django, 'setup'): # Django >= 1.7 requires this for setting up the application. django.setup() if django.VERSION < (1, 7): # must be imported after settings are set up from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() from django.test.utils import get_runner TestRunner = get_runner(settings) if not test_labels: # apps to test test_labels = CORE_TEST_MODULES + get_contrib_test_modules() test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) failures = test_runner.run_tests(test_labels) teardown() return failures
def __enter__(self): try: patch_for_test_db_setup() except NameError: pass connection.creation.create_test_db(self.verbosity)
def handle(self, *test_labels, **options): from django.conf import settings from django.test.utils import get_runner patch_for_test_db_setup() test_labels = ('locations', 'parsed_xforms', \ 'nga_districts', 'phone_manager', 'surveyor_manager', \ 'xform_manager', 'map_xforms', 'submission_qr',) verbosity = int(options.get('verbosity', 1)) interactive = options.get('interactive', True) failfast = options.get('failfast', False) TestRunner = get_runner(settings) if hasattr(TestRunner, 'func_name'): # Pre 1.2 test runners were merely functions, # and did not support the 'failfast' option. import warnings warnings.warn( 'Function-based test runners are deprecated. Test runners should be classes with a run_tests() method.', PendingDeprecationWarning ) failures = TestRunner(test_labels, verbosity=verbosity, interactive=interactive) else: test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) failures = test_runner.run_tests(test_labels) if failures: sys.exit(bool(failures))
def setup_databases(self): if 'south' in settings.INSTALLED_APPS: from south.management.commands import ( patch_for_test_db_setup # pylint: disable=F0401 ) patch_for_test_db_setup() return super(CITestSuiteRunner, self).setup_databases()
def south_patch(self): try: from south.management.commands import patch_for_test_db_setup except ImportError: pass else: patch_for_test_db_setup()
def switch_to_test_database(): """ Switching to the test database """ logging.info("Setting up a test database ...\n") try: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except ImportError: pass world.test_runner = DjangoTestSuiteRunner(interactive=False) world.test_runner.setup_test_environment() world.test_db = world.test_runner.setup_databases() call_command('syncdb', **{ 'settings': settings.SETTINGS_MODULE, 'interactive': False, 'verbosity': 0 }) # Reload mongodb database settings.MONGODB_DATABASE = settings.MONGODB_TEST_DATABASE for model in [Document, Entry, Notification]: model.objects.load() model.objects.collection.remove()
def _handle_south(): from django.conf import settings if 'south' in settings.INSTALLED_APPS: # Handle south. from django.core import management try: # if `south` >= 0.7.1 we can use the test helper from south.management.commands import patch_for_test_db_setup except ImportError: # if `south` < 0.7.1 make sure it's migrations are disabled management.get_commands() management._commands['syncdb'] = 'django.core' else: # Monkey-patch south.hacks.django_1_0.SkipFlushCommand to load # initial data. # Ref: http://south.aeracode.org/ticket/1395#comment:3 import south.hacks.django_1_0 from django.core.management.commands.flush import ( Command as FlushCommand) class SkipFlushCommand(FlushCommand): def handle_noargs(self, **options): # Reinstall the initial_data fixture. from django.core.management import call_command # `load_initial_data` got introduces with Django 1.5. load_initial_data = options.get('load_initial_data', None) if load_initial_data or load_initial_data is None: # Reinstall the initial_data fixture. call_command('loaddata', 'initial_data', **options) # no-op to avoid calling flush return south.hacks.django_1_0.SkipFlushCommand = SkipFlushCommand patch_for_test_db_setup()
def handle(self, *args, **options): # Replace the DB name with test DB name in main settings # since this is what destroy_test_db looks for to determine # the name of the test_db. for alias in connections: connection = connections[alias] original_name = connection.settings_dict['NAME'] if connection.settings_dict['TEST_NAME']: test_database_name = connection.settings_dict['TEST_NAME'] else: test_database_name = TEST_DATABASE_PREFIX + connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_database_name # try to delete db if it already exists, so we can recreate. try: connection.creation.destroy_test_db(original_name) except Exception, e: pass # check if we have south installed, and so overide syncdb so # we also run migrations. Uses same method as south's test # command override. try: from south.management.commands import patch_for_test_db_setup except ImportError: patch_for_test_db_setup = lambda: None patch_for_test_db_setup() connection.creation.create_test_db()
def handle(self, *test_labels, **options): """Trigger both south and selenium tests.""" run_south_tests = bool(options.get('run_normal_tests', False)) run_selenium_tests = bool(options.get('run_selenium_tests', False)) # Check test types if (run_south_tests and run_selenium_tests or not run_south_tests and not run_selenium_tests): logger.error("You must specify exactly one of --selenium-tests and --normal-tests.") sys.exit(1) # Apply the south patch for syncdb, migrate commands during tests patch_for_test_db_setup() if run_south_tests: test_south.Command.handle(self, *test_labels, **options) elif run_selenium_tests: # We don't want to call any super handle function, because it will # try to run tests in addition to parsing command line options. # Instead, we parse the relevant options ourselves. verbosity = int(options.get('verbosity', 1)) interactive = options.get('interactive', True) failfast = options.get('failfast', False) test_runner = SeleniumTestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) test_runner.selenium = True test_runner.selenium_only = True failures = test_runner.run_tests(test_labels) if failures: sys.exit(bool(failures))
def setup_databases(self, verbosity, autoclobber, **kwargs): # Taken from Django 1.2 code, (C) respective Django authors. Modified for backward compatibility by me connections = self._get_databases() old_names = [] mirrors = [] from django.conf import settings if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup settings.SOUTH_TESTS_MIGRATE = getattr(settings, 'DST_RUN_SOUTH_MIGRATIONS', True) patch_for_test_db_setup() for alias in connections: connection = connections[alias] # If the database is a test mirror, redirect it's connection # instead of creating a test database. if 'TEST_MIRROR' in connection.settings_dict and connection.settings_dict['TEST_MIRROR']: mirrors.append((alias, connection)) mirror_alias = connection.settings_dict['TEST_MIRROR'] connections._connections[alias] = connections[mirror_alias] else: if 'NAME' in connection.settings_dict: old_names.append((connection, connection.settings_dict['NAME'])) else: old_names.append((connection, connection.settings_dict['DATABASE_NAME'])) connection.creation.create_test_db(verbosity=verbosity, autoclobber=autoclobber) return old_names, mirrors
def handle(self, *args, **options): USE_SOUTH = getattr(settings, "SOUTH_TESTS_MIGRATE", True) try: if USE_SOUTH: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except: USE_SOUTH = False self._test_runner = DjangoTestSuiteRunner(interactive=False) DjangoTestSuiteRunner.setup_test_environment(self._test_runner) self._created_db = DjangoTestSuiteRunner.setup_databases(self._test_runner) call_command('syncdb', verbosity=0, interactive=False,) if USE_SOUTH: call_command('migrate', verbosity=0, interactive=False,) settings.DEBUG = options.get('debug', False) verbosity = int(options.get('verbosity', 4)) apps_to_run = tuple(options.get('apps', '').split(",")) apps_to_avoid = tuple(options.get('avoid_apps', '').split(",")) run_server = not options.get('no_server', False) tags = options.get('tags', None) server = Server(port=options['port']) paths = self.get_paths(args, apps_to_run, apps_to_avoid) if run_server: try: server.start() except LettuceServerException, e: raise SystemExit(e)
def setUp(self): # Set up the django test framework. os.environ['DJANGO_SETTINGS_MODULE'] = 'website.settings' from django.conf import settings from django.test.utils import setup_test_environment from django.db import connection from south.management.commands import patch_for_test_db_setup # If DEBUG = True, django will sometimes take different code paths. settings.DEBUG = False self.django_db = settings.DATABASE_NAME setup_test_environment() patch_for_test_db_setup() connection.creation.create_test_db(verbosity=0) # A fake cardstories service just to benefit from settings directories. class FakeService: def __init__(self, settings): self.settings = settings # Instantiate our test subject. self.auth = djangoauth.Plugin(FakeService({'plugins-libdir': '.', 'plugins-confdir': '../fixture'}), []) # Use the fake client in the plugin instead of twisted's getPage. self.auth.getPage = FakeTwistedWebClient().getPage
def runtests(verbosity=1, interactive=False, failfast=False, *test_args): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = UnaccentDjangoTestSuiteRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) return test_runner.run_tests(test_labels=None, extra_tests=None)
def main(): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = get_runner(settings)(interactive=False, verbosity=2) failures = test_runner.run_tests(['peavy']) sys.exit(failures)
def main(): from django.test.utils import get_runner from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = get_runner(settings)(interactive=False) failures = test_runner.run_tests([app.split('.')[-1] for app in TEST_APPS]) sys.exit(failures)
def setup_django_test_database(): from django.test.simple import DjangoTestSuiteRunner from django.test.utils import setup_test_environment from south.management.commands import patch_for_test_db_setup runner = DjangoTestSuiteRunner(verbosity=0, failfast=False) patch_for_test_db_setup() setup_test_environment() return runner, runner.setup_databases()
def main(): TestRunner = get_runner(settings) # Ugly parameter parsing. We probably want to improve that in future # or just use default django test command. This may be problematic, # knowing how testing in Django changes from version to version. if '-p' in sys.argv: try: pos = sys.argv.index('-p') pattern = sys.argv.pop(pos) and sys.argv.pop(pos) except IndexError: print(usage()) sys.exit(1) else: pattern = None test_modules = sys.argv[1:] test_runner = TestRunner(verbosity=2, failfast=False, pattern=pattern) if len(sys.argv) > 1: test_modules = sys.argv[1:] elif len(sys.argv) == 1: test_modules = [] else: print(usage()) sys.exit(1) if (1, 6, 0) <= django.VERSION < (1, 9, 0): # this is a compat hack because in django>=1.6.0 you must provide # module like "userena.contrib.umessages" not "umessages" from django.db.models import get_app test_modules = [ # be more strict by adding .tests to not run umessages tests twice # if both userena and umessages are tested get_app(module_name).__name__[:-7] + ".tests" for module_name in test_modules ] elif django.VERSION >= (1, 9, 0): from django.apps import apps test_modules = [ # be more strict by adding .tests to not run umessages tests twice # if both userena and umessages are tested apps.get_app_config(module_name).name + ".tests" for module_name in test_modules ] if django.VERSION < (1, 7, 0): # starting from 1.7.0 built in django migrations are run # for older releases this patch is required to enable testing with # migrations from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() failures = test_runner.run_tests(test_modules or ['userena']) sys.exit(failures)
def runtests(): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=1, interactive=True) failures = test_runner.run_tests(['tester']) sys.exit(bool(failures))
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = NoseTestSuiteRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(): patch_for_test_db_setup() apps = sys.argv[1:] or ['allaccess', ] if SWAPPED and VERSION[0] == 1 and VERSION[1] < 6: apps.append('custom') TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=1, interactive=True, failfast=False) failures = test_runner.run_tests(apps) sys.exit(failures)
def __init__(self, *test_args, **kwargs): super(TestsWrapper, self).__init__() if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['cmsroles.tests'] kwargs.setdefault('interactive', False) test_runner = NoseTestSuiteRunner(**kwargs) self._failures = test_runner.run_tests(test_args)
def _handle_south_management_command(): try: # if `south` >= 0.7.1 we can use the test helper from south.management.commands import patch_for_test_db_setup except ImportError: # if `south` < 0.7.1 make sure it's migrations are disabled management.get_commands() management._commands['syncdb'] = 'django.core' else: patch_for_test_db_setup()
def patch_settings(options): """ Patch Django settings/environment. """ if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if options.get('liveserver') is not None: os.environ['DJANGO_LIVE_TEST_SERVER_ADDRESS'] = options['liveserver']
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['attachments'] failures = run_tests(test_args, verbosity=kwargs.get('verbosity', 1), interactive=kwargs.get('interactive', False), failfast=kwargs.get('failfast')) sys.exit(failures)
def setup(): setup_test_environment() if not hasattr(settings, 'DEBUG'): settings.DEBUG = False if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() from django.db import connection connection.creation.create_test_db(1, True) return Client()
def runtests(*test_args): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['sentry'] parent = dirname(abspath(__file__)) sys.path.insert(0, parent) failures = run_tests(test_args, verbosity=1, interactive=True) sys.exit(failures)
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['tests'] test_runner = NoseTestSuiteRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(verbosity, failfast, interactive, test_labels): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_runner = DjangoTestSuiteRunner( verbosity=verbosity, interactive=interactive, failfast=failfast) sys.exit(test_runner.run_tests(test_labels))
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['tests'] parent = dirname(abspath(__file__)) sys.path.insert(0, parent) test_runner = DjangoTestSuiteRunner(verbosity=kwargs.get('verbosity', 1), interactive=kwargs.get('interactive', False), failfast=kwargs.get('failfast')) failures = test_runner.run_tests(test_args) sys.exit(failures)
def handle(self, *args, **options): setup_test_environment() verbosity = int(options.get('verbosity', 3)) no_color = int(options.get('no_color', False)) apps_to_run = tuple(options.get('apps', '').split(",")) apps_to_avoid = tuple(options.get('avoid_apps', '').split(",")) run_server = not options.get('no_server', False) test_database = options.get('test_database', False) smtp_queue = options.get('smtp_queue', False) tags = options.get('tags', None) failfast = options.get('failfast', False) auto_pdb = options.get('auto_pdb', False) threading = options.get('use_threading', True) with_summary = options.get('summary_display', False) if test_database: migrate_south = getattr(settings, "SOUTH_TESTS_MIGRATE", True) try: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except: migrate_south = False pass from django.test.utils import get_runner self._testrunner = get_runner(settings)(interactive=False) self._testrunner.setup_test_environment() self._old_db_config = self._testrunner.setup_databases() call_command( 'syncdb', verbosity=0, interactive=False, ) if migrate_south: call_command( 'migrate', verbosity=0, interactive=False, ) settings.DEBUG = options.get('debug', False) paths = self.get_paths(args, apps_to_run, apps_to_avoid) server = get_server(port=options['port'], threading=threading) if run_server: try: server.start() except LettuceServerException, e: raise SystemExit(e)
def runtests(): if hasattr(django, 'setup'): django.setup() patch_for_test_db_setup() apps = sys.argv[1:] or [ 'allaccess', ] if SWAPPED and VERSION[0] == 1 and VERSION[1] < 6: apps.append('custom') TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=1, interactive=True, failfast=False) failures = test_runner.run_tests(apps) sys.exit(failures)
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['tests'] parent = dirname(abspath(__file__)) sys.path.insert(0, parent) test_runner = prepare_test_runner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['contact_form'] failures = run_tests(test_args, verbosity=kwargs.get('verbosity', 1), interactive=kwargs.get('interactive', False), failfast=kwargs.get('failfast')) sys.exit(failures)
def before_all(context): # Even though DJANGO_SETTINGS_MODULE is set, this may still be # necessary. Or it may be simple CYA insurance. from django.core.management import setup_environ from vsq import settings setup_environ(settings) ### Take a TestRunner hostage. from django.test.simple import DjangoTestSuiteRunner # We'll use thise later to frog-march Django through the motions # of setting up and tearing down the test environment, including # test databases. context.runner = DjangoTestSuiteRunner(verbosity=2) ## If you use South for migrations, uncomment this to monkeypatch ## syncdb to get migrations to run. from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() ### Set up the WSGI intercept "port". import wsgi_intercept, urlparse from django.core.handlers.wsgi import WSGIHandler host = context.host = 'localhost' port = context.port = getattr(settings, 'TESTING_MECHANIZE_INTERCEPT_PORT', 17681) # NOTE: Nothing is actually listening on this port. wsgi_intercept # monkeypatches the networking internals to use a fake socket when # connecting to this port. wsgi_intercept.add_wsgi_intercept(host, port, WSGIHandler) def browser_url(url): """Create a URL for the virtual WSGI server. e.g context.browser_url('/'), context.browser_url(reverse('my_view')) """ return urlparse.urljoin('http://%s:%d/' % (host, port), url) context.browser_url = browser_url ### BeautifulSoup is handy to have nearby. (Substitute lxml or html5lib as you see fit) from bs4 import BeautifulSoup def parse_soup(): """Use BeautifulSoup to parse the current response and return the DOM tree. """ r = context.browser.response() html = r.read() r.seek(0) return BeautifulSoup(html) context.parse_soup = parse_soup
def handle(self, *test_labels, **options): patch_for_test_db_setup() output_dir = options.get('output_dir') verbosity = int(options.get('verbosity', 1)) interactive = options.get('interactive', True) test_runner = XmlDjangoTestSuiteRunner(output_dir=output_dir, interactive=interactive, verbosity=verbosity) failures = test_runner.run_tests(test_labels) if failures: sys.exit(bool(failures))
def run_tests(*test_args): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['tests'] # Run tests test_runner = NoseTestSuiteRunner(verbosity=1) num_failures = test_runner.run_tests(test_args) if num_failures > 0: sys.exit(num_failures)
def run_tests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['entity_emailer'] kwargs.setdefault('interactive', False) test_runner = NoseTestSuiteRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(*test_args, **kwargs): if django.VERSION[:2] >= (1, 7): django.setup() if 'south' in settings.INSTALLED_APPS and south_installed: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['pybb'] test_runner = Runner(verbosity=kwargs.get('verbosity', 1), interactive=kwargs.get('interactive', False), failfast=kwargs.get('failfast')) failures = test_runner.run_tests(test_args) sys.exit(failures)
def handle(self, *test_labels, **options): patch_for_test_db_setup() from django.conf import settings from django.test.utils import get_runner verbosity = int(options.get('verbosity', 1)) interactive = options.get('interactive', True) failfast = options.get('failfast', False) TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) failures = test_runner.run_tests(test_labels) sys.exit(bool(failures))
def handle(self, *test_labels, **options): # HACK: ensure Django configuratio is read in configure(**getattr(settings, 'MULE_CONFIG', {})) settings.TEST = True settings.DEBUG = False if 'south' in settings.INSTALLED_APPS: patch_for_test_db_setup() test_runner = DjangoTestSuiteRunner(**options) result = test_runner.run_tests(test_labels) if result: sys.exit(bool(result))
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['celery_rpc'] if sys.version_info >= (3, 10, 0): from django.test.runner import DiscoverRunner test_runner = DiscoverRunner(**kwargs) else: test_runner = NoseTestSuiteRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(*test_args): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['ticketing'] parent = dirname(abspath(__file__)) sys.path.insert(0, parent) from django.test.utils import get_runner TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=0, interactive=True, failfast=True) failures = test_runner.run_tests(test_args) sys.exit(bool(failures))
def main(): TestRunner = get_runner(settings) test_runner = TestRunner(verbosity=2) if len(sys.argv) == 2: test_case = '.' + sys.argv[1] elif len(sys.argv) == 1: test_case = '' else: print(usage()) sys.exit(1) patch_for_test_db_setup() failures = test_runner.run_tests(['tests' + test_case]) sys.exit(failures)
def configure(**extra): from django.conf import settings os.environ['DJANGO_SETTINGS_MODULE'] = 'filer.test_utils.cli' defaults = dict( DEBUG=True, TEMPLATE_DEBUG=True, DATABASE_SUPPORTS_TRANSACTIONS=True, DATABASES={'default': { 'ENGINE': 'django.db.backends.sqlite3' }}, USE_I18N=True, MEDIA_ROOT='/media/', STATIC_ROOT='/static/', MEDIA_URL='/media/', STATIC_URL='/static/', EMAIL_BACKEND='django.core.mail.backends.locmem.EmailBackend', SECRET_KEY='key', TEMPLATE_LOADERS=( 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', 'django.template.loaders.eggs.Loader', ), SOUTH_TESTS_MIGRATE=True, INSTALLED_APPS=[ 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.admin', 'django.contrib.sessions', 'django.contrib.staticfiles', 'easy_thumbnails', 'mptt', 'filer', 'south', ], ROOT_URLCONF='filer.test_utils.cli', ) if ET_2: extra['SOUTH_MIGRATION_MODULES'] = { 'easy_thumbnails': 'easy_thumbnails.south_migrations', } defaults.update(extra) settings.configure(**defaults) from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() from django.contrib import admin admin.autodiscover()
def before_all(context): settings = chroma_settings() from django.core.management import setup_environ setup_environ(settings) ### Take a TestRunner hostage. # Use django_nose's runner so that we can take advantage of REUSE_DB=1. from django_nose import NoseTestSuiteRunner # We'll use these later to frog-march Django through the motions # of setting up and tearing down the test environment, including # test databases. context.runner = NoseTestSuiteRunner() ## If you use South for migrations, uncomment this to monkeypatch ## syncdb to get migrations to run. from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup()
def setup_database(actual_server): ''' This will setup your database, sync it, and run migrations if you are using South. It does this before the Test Django server is set up. ''' logger.info("Setting up a test database...") # Uncomment if you are using South patch_for_test_db_setup() world.test_runner = DjangoTestSuiteRunner(interactive=False) DjangoTestSuiteRunner.setup_test_environment(world.test_runner) world.created_db = DjangoTestSuiteRunner.setup_databases(world.test_runner) call_command('syncdb', interactive=False, verbosity=0) # Uncomment if you are using South call_command('migrate', interactive=False, verbosity=0)
def __init__(self, *args, **kwargs): self.cov = coverage() self.cov.start() self.configure() self.packages = self.resolve_packages() parser = argparse.ArgumentParser() parser.add_argument('-a', '--autoreload', dest='autoreload', action='store_const', const=True, default=False,) parser.add_argument('-f', '--failfast', dest='failfast', action='store_const', const=True, default=False,) parser.add_argument('-l', '--label', dest='label') self.options = vars(parser.parse_args(sys.argv[2:])) sys.argv = sys.argv[:2] runner_options = { 'verbosity': 1, 'interactive': True, 'failfast': False, } if django.VERSION >= (1, 8): from django.test.runner import DiscoverRunner self.test_runner = DiscoverRunner(**runner_options) tests = self.test_runner.build_suite() else: from django.test.simple import DjangoTestSuiteRunner self.test_runner = DjangoTestSuiteRunner(**runner_options) tests = self.build_tests() super(SetupTestSuite, self).__init__(tests=tests, *args, **kwargs) # South patches the test management command to handle the # SOUTH_TESTS_MIGRATE setting. Apply that patch if South is installed. if django.VERSION < (1,7): try: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except ImportError: pass self.test_runner.setup_test_environment() self.old_config = self.test_runner.setup_databases()
def runtests(*test_args, **kwargs): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['djangoratings'] import django try: django.setup() except AttributeError: pass kwargs.setdefault('interactive', False) test_runner = DiscoverRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)
def runtests(*test_args): from django.test.simple import DjangoTestSuiteRunner if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: ## setup.py test test_args = ['ajaxutils_tests', '--jenkins'] parent = dirname(abspath(__file__)) sys.path.insert(0, parent) if '--jenkins' in test_args: call_command('jenkins', 'ajaxutils_tests', verbosity=1, interactive=True) sys.exit(0) else: failures = DjangoTestSuiteRunner().run_tests(test_args) sys.exit(failures)
def run_tests(*test_args): if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() if not test_args: test_args = ['tests'] # Run tests test_runner = NoseTestSuiteRunner(verbosity=1) c = coverage(source=['oscar_stripe'], omit=['*migrations*', '*tests*']) c.start() num_failures = test_runner.run_tests(test_args) c.stop() if num_failures > 0: sys.exit(num_failures) print "Generating HTML coverage report" c.html_report()
def handle(self, *args, **options): USE_SOUTH = getattr(settings, "SOUTH_TESTS_MIGRATE", True) try: if USE_SOUTH: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() except: USE_SOUTH = False self._test_runner = DjangoTestSuiteRunner(interactive=False) DjangoTestSuiteRunner.setup_test_environment(self._test_runner) self._created_db = DjangoTestSuiteRunner.setup_databases( self._test_runner) call_command( 'syncdb', verbosity=0, interactive=False, ) if USE_SOUTH: call_command( 'migrate', verbosity=0, interactive=False, ) settings.DEBUG = options.get('debug', False) verbosity = int(options.get('verbosity', 4)) apps_to_run = tuple(options.get('apps', '').split(",")) apps_to_avoid = tuple(options.get('avoid_apps', '').split(",")) run_server = not options.get('no_server', False) tags = options.get('tags', None) server = Server(port=options['port']) paths = self.get_paths(args, apps_to_run, apps_to_avoid) if run_server: try: server.start() except LettuceServerException, e: raise SystemExit(e)
def run_tests(*test_labels, **options): patch_for_test_db_setup() verbosity = int(options.get('verbosity', 1)) interactive = options.get('interactive', True) failfast = options.get('failfast', False) nocolor = options.get('nocolor', False) TestSuiteRunner = get_runner(settings) class NewTestSuiteRunner(TestSuiteRunner): def run_suite(self, suite, **kwargs): return get_test_runner(nocolor)( verbosity=self.verbosity).run(suite) def suite_result(self, suite, result, **kwargs): return result test_runner = NewTestSuiteRunner(verbosity=verbosity, interactive=interactive, failfast=failfast) result = test_runner.run_tests(test_labels) return result
def configure(**extra): from django.conf import settings defaults = dict( CACHE_BACKEND='locmem:///', DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:', } }, SOUTH_TESTS_MIGRATE=False, PASSWORD_HASHERS=( 'django.contrib.auth.hashers.MD5PasswordHasher', ) ) defaults.update(extra) for key, value in defaults.items(): setattr(settings, key, value) from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() logging.disable(logging.CRITICAL)
def before_all(context): from django.test.simple import DjangoTestSuiteRunner # We'll use thise later to frog-march Django through the motions # of setting up and tearing down the test environment, including # test databases. context.runner = DjangoTestSuiteRunner() patch_for_test_db_setup() host = context.host = 'localhost' port = context.port = getattr(settings, 'TESTING_MECHANIZE_INTERCEPT_PORT', 17681) # NOTE: Nothing is actually listening on this port. wsgi_intercept # monkeypatches the networking internals to use a fake socket when # connecting to this port. wsgi_intercept.add_wsgi_intercept(host, port, WSGIHandler) def browser_url(url): """Create a URL for the virtual WSGI server. e.g context.browser_url('/'), context.browser_url(reverse('my_view')) """ return urlparse.urljoin('http://%s:%d/' % (host, port), url) context.browser_url = browser_url def parse_soup(): r = context.browser.response() h = r.read() r.seek(0) return BeautifulSoup(h) context.parse_soup = parse_soup def parse_lxml(): r = context.browser.response() data = r.read() r.seek(0) return html.fromstring(data) context.parse_lxml = parse_lxml
def _handle_south(): from django.conf import settings # NOTE: Django 1.7 does not have `management._commands` anymore, which # is used by South's `patch_for_test_db_setup` and the code below. if 'south' not in settings.INSTALLED_APPS or get_django_version() > (1, 7): return from django.core import management try: # if `south` >= 0.7.1 we can use the test helper from south.management.commands import patch_for_test_db_setup except ImportError: # if `south` < 0.7.1 make sure its migrations are disabled management.get_commands() management._commands['syncdb'] = 'django.core' else: # Monkey-patch south.hacks.django_1_0.SkipFlushCommand to load # initial data. # Ref: http://south.aeracode.org/ticket/1395#comment:3 import south.hacks.django_1_0 from django.core.management.commands.flush import (Command as FlushCommand) class SkipFlushCommand(FlushCommand): def handle_noargs(self, **options): # Reinstall the initial_data fixture. from django.core.management import call_command # `load_initial_data` got introduces with Django 1.5. load_initial_data = options.get('load_initial_data', None) if load_initial_data or load_initial_data is None: # Reinstall the initial_data fixture. call_command('loaddata', 'initial_data', **options) # no-op to avoid calling flush return south.hacks.django_1_0.SkipFlushCommand = SkipFlushCommand patch_for_test_db_setup()
def runtests(*test_args, **kwargs): from django_nose import NoseTestSuiteRunner if 'south' in settings.INSTALLED_APPS: from south.management.commands import patch_for_test_db_setup patch_for_test_db_setup() test_args = test_args or [] if 'verbosity' in kwargs: kwargs['verbosity'] = int(kwargs['verbosity']) kwargs.setdefault('interactive', False) test_args.append('--with-coverage') test_args.append('--cover-package=swingers') test_args.append('--cover-xml') test_args.append('--cover-xml-file=coverage.xml') test_runner = NoseTestSuiteRunner(**kwargs) failures = test_runner.run_tests(test_args) sys.exit(failures)