コード例 #1
0
ファイル: tests.py プロジェクト: bitcredit-currency/mybitbank
 def setUp(self):
     setup_test_environment()
     connector.services = {'btc': ServiceProxyStubBTC()}
     
     from django.contrib.auth.models import User
     user = User.objects.create_user('testing', '*****@*****.**', 'testingpassword')
     user.save()
コード例 #2
0
ファイル: runtests.py プロジェクト: sys520084/djblets
def run_tests(verbosity=1, interactive=False):
    from django.conf import settings
    from django.core import management
    from django.db import connection
    from django.test.utils import setup_test_environment, \
                                  teardown_test_environment

    setup_test_environment()
    settings.DEBUG = False

    if not os.path.exists(settings.EXTENSIONS_MEDIA_ROOT):
        os.mkdir(settings.EXTENSIONS_MEDIA_ROOT, 0755)

    old_db_name = 'default'
    connection.creation.create_test_db(verbosity, autoclobber=not interactive)
    management.call_command('syncdb', verbosity=verbosity,
                            interactive=interactive)

    nose_argv = ['runtests.py', '-v',
                 '--with-coverage',
                 '--with-doctest',
                 '--doctest-extension=.txt',
                 '--cover-package=djblets']

    if len(sys.argv) > 2:
        node_argv += sys.argv[2:]

    nose.main(argv=nose_argv)

    connection.creation.destroy_test_db(old_name, verbosity)
    teardown_test_environment()
コード例 #3
0
ファイル: simple.py プロジェクト: alatteri/informer
def run_tests(module_list, verbosity=1, extra_tests=[]):
    """
    Run the unit tests for all the modules in the provided list.
    This testrunner will search each of the modules in the provided list,
    looking for doctests and unittests in models.py or tests.py within
    the module. 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()
     
    for module in module_list:
        suite.addTest(build_suite(module))
    
    for test in extra_tests:
        suite.addTest(test)

    old_name = settings.DATABASE_NAME
    create_test_db(verbosity)
    result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
    destroy_test_db(old_name, verbosity)
    
    teardown_test_environment()
    
    return len(result.failures) + len(result.errors)
    
コード例 #4
0
ファイル: test_djangoauth.py プロジェクト: B-Rich/cardstories
    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
コード例 #5
0
ファイル: test_django.py プロジェクト: elbaschid/factory_boy
def setUpModule():
    if django is None:  # pragma: no cover
        raise unittest.SkipTest("Django not installed")
    django_test_utils.setup_test_environment()
    runner = django_test_simple.DjangoTestSuiteRunner()
    runner_state = runner.setup_databases()
    test_state.update({"runner": runner, "runner_state": runner_state})
コード例 #6
0
ファイル: test_contrib.py プロジェクト: whtsky/WeRoBot
def test_django():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_test.settings")
    sys.path.append(
        os.path.join(
            os.path.abspath(os.path.dirname(__file__)), 'django_test_env'
        )
    )

    from django.test.utils import setup_test_environment
    setup_test_environment()
    from django.test.client import Client
    from werobot.parser import parse_xml, process_message
    import django

    django.setup()
    client = Client()

    token = 'TestDjango'
    timestamp = str(time.time())
    nonce = str(random.randint(0, 10000))
    signature = get_signature(token, timestamp, nonce)
    echostr = generate_token()

    response = client.get(
        '/robot/', {
            'signature': signature,
            'timestamp': timestamp,
            'nonce': nonce,
            'echostr': echostr
        }
    )
    assert response.status_code == 200
    assert response.content.decode('utf-8') == echostr

    xml = """
    <xml>
        <ToUserName><![CDATA[toUser]]></ToUserName>
        <FromUserName><![CDATA[fromUser]]></FromUserName>
        <CreateTime>1348831860</CreateTime>
        <MsgType><![CDATA[text]]></MsgType>
        <Content><![CDATA[this is a test]]></Content>
        <MsgId>1234567890123456</MsgId>
    </xml>"""
    params = "?timestamp=%s&nonce=%s&signature=%s" % \
             (timestamp, nonce, signature)
    url = '/robot/'
    response = client.post(url, data=xml, content_type="text/xml")

    assert response.status_code == 403
    assert response.content.decode('utf-8') == u'喵'

    url += params
    response = client.post(url, data=xml, content_type="text/xml")

    assert response.status_code == 200
    response = process_message(parse_xml(response.content))
    assert response.content == 'hello'

    response = client.options(url)
    assert response.status_code == 405
コード例 #7
0
ファイル: pytest.py プロジェクト: SMU-SIS/code-worker
 def before_testfile(self):
     # Those imports must be done **after** setup_environ was called
     from django.test.utils import setup_test_environment
     from django.test.utils import create_test_db
     setup_test_environment()
     create_test_db(verbosity=0)
     self.dbname = self.settings.TEST_DATABASE_NAME
コード例 #8
0
 def test_password_change_with_mail_token(self, reset_mock, cassy_mock):
     """
     Tests the case where a user logs in after
     receiving gotten a password reset email.
     """
     setup_test_environment()
     client = Client()
     username = os.environ.get('LOGIN_USERNAME')
     old_password = os.environ.get('LOGIN_PASSWORD')
     new_password = '******'
     body = {
         'token': os.environ.get('LOGIN_SEC_TOKEN'),
         'username': username,
         'password': new_password,
     }
     response = client.post(
         '/password/change',
         data=json.dumps(body),
         content_type='application/json'
     )
     cassy_mock.assert_called_once_with(
         username,
         new_password,
         old_password
     )
     reset_mock.assert_called_once_with(
         username,
         new_password
     )
     self.assertEqual(response.status_code, 200)
コード例 #9
0
ファイル: utils.py プロジェクト: techdragon/instant-coverage
def get_results_for(test_name, mixin=None, **test_attributes):
    from instant_coverage import InstantCoverageMixin

    if mixin is None:
        class EverythingTest(InstantCoverageMixin, TestCase):
            pass
    else:
        class EverythingTest(mixin, InstantCoverageMixin, TestCase):
            pass

    setup_test_environment()
    test = EverythingTest(test_name)

    for attribute, value in six.iteritems(test_attributes):
        setattr(test, attribute, value)

    result = PickyTestResult()

    test._pre_setup()

    test.run(result)

    if not result.errors == []:
        # there should only ever be failures; if there's an error we should
        # throw something useful
        raise Exception(result.errors[0][1])
    return result
コード例 #10
0
ファイル: templateshell.py プロジェクト: caogecym/muer
 def handle(self, url, context, use_pdb, *args, **kwargs):
     if context:
         context_dict = eval(context)
     else:
         context_dict = {}
     context = Context(context_dict)
     if url is not None:
         setup_test_environment()
         client = Client()
         response = client.get(url)
         if not response.context:
             print 'Response for given URL contains no context (code %s).' % response.status_code
         else:
             if isinstance(response.context, Context):
                 context = response.context
             elif type(response.context) == list:
                 context = response.context[0]
             else:
                 try:
                     from django.test.utils import ContextList
                 except ImportError:
                     pass
                 else:
                     if isinstance(response.context, ContextList):
                         # TODO: probably should try to merge all contexts
                         context = response.context[0]
     if use_pdb:
         pdb_with_context(context)
     else:
         run_shell(context)
コード例 #11
0
ファイル: base.py プロジェクト: bmihelac/django-test-utils
    def run(self, max_depth=3):
        for p in self.plugins:
            p.set_output_dir(self.output_dir)

        old_DEBUG = settings.DEBUG
        settings.DEBUG = False

        setup_test_environment()
        test_signals.start_run.send(self)

        # To avoid tainting our memory usage stats with startup overhead we'll
        # do one extra request for the first page now:
        self.c.get(self.not_crawled[0][-1])

        while self.not_crawled:
            #Take top off not_crawled and evaluate it
            current_depth, from_url, to_url = self.not_crawled.pop(0)
            if current_depth > max_depth:
                continue

            transaction.enter_transaction_management()
            try:
                resp, returned_urls = self.get_url(from_url, to_url)
            except HTMLParseError, e:
                LOG.error("%s: unable to parse invalid HTML: %s", to_url, e)
            except Exception, e:
                LOG.exception("%s had unhandled exception: %s", to_url, e)
                continue
コード例 #12
0
ファイル: terrain.py プロジェクト: pedromarins/estagiario
def initial_setup(server):
    call_command('syncdb', interactive=False, verbosity=0)
    call_command('flush', interactive=False, verbosity=0)
    call_command('migrate', interactive=False, verbosity=0)
    call_command('loaddata', 'all', verbosity=0)
    setup_test_environment()
    world.browser = Browser('webdriver.firefox')
コード例 #13
0
def setup():
    """
    set up test environment
    """

    # add test/src folders to sys path
    test_folder = os.path.abspath(os.path.dirname(__file__))
    src_folder = os.path.abspath(os.path.join(test_folder, os.pardir))
    sys.path.insert(0, test_folder)
    sys.path.insert(0, src_folder)

    # define settings
    import django.conf

    os.environ[django.conf.ENVIRONMENT_VARIABLE] = "settings"

    # set up environment
    from django.test.utils import setup_test_environment

    setup_test_environment()

    # See https://docs.djangoproject.com/en/dev/releases/1.7/#app-loading-changes
    import django

    if django.VERSION >= (1, 7, 0):
        django.setup()

    # set up database
    from django.db import connection

    connection.creation.create_test_db()
コード例 #14
0
ファイル: nose2django.py プロジェクト: yunmanger1/nose2django
    def startTestRun(self, event):
        """Nose2 hook for the beginning of test running.
        Init the django environ and re-order the tests according to
        the django documented test runner behaviour.
        """
        from django.test.simple import DjangoTestSuiteRunner
        # reorder_suite, 
        from django.test.utils import setup_test_environment
        # Init the django default runner so we can call it's functions as needed
        self.dtsr = DjangoTestSuiteRunner()

        setup_test_environment()

        # event.suite = reorder_suite(event.suite, (unittest.TestCase,))

        self.old_config = self.dtsr.setup_databases()
        
        if self.session.verbosity > 1:
            # ensure that deprecation warnings are displayed during testing
            # the following state is assumed:
            # logging.capturewarnings is true
            # a "default" level warnings filter has been added for
            # DeprecationWarning. See django.conf.LazySettings._configure_logging
            self.logger = logging.getLogger('py.warnings')
            handler = logging.StreamHandler()
            self.logger.addHandler(handler)
コード例 #15
0
def run_tests(settings):
    from django.test.utils import get_runner
    from django.utils.termcolors import colorize
    from django.test.utils import setup_test_environment
    version = django.get_version()
    if version.startswith("1.7"):
        django.setup()
    db_conf = settings.DATABASES['default']
    setup_test_environment()
    output = []
    msg = "Starting tests for db backend: %s" % db_conf['ENGINE']
    embracer = '=' * len(msg)
    output.append(msg)
    for key, value in db_conf.iteritems():
        if key == 'PASSWORD':
            value = '****************'
        line = '    %s: "%s"' % (key, value)
        output.append(line)
    embracer = colorize('=' * len(max(output, key=lambda s: len(s))),
        fg='green', opts=['bold'])
    output = [colorize(line, fg='blue') for line in output]
    output.insert(0, embracer)
    output.append(embracer)
    print '\n'.join(output)

    TestRunner = get_runner(settings)
    test_runner = TestRunner(interactive=False)
    failures = test_runner.run_tests(['password_policies'])
    return failures
コード例 #16
0
    def test_email_change(self, send_mail_mock):
        """
        Test env data endpoint when temperature data is requested.
        """
        username = "******"
        old_email = cassy.get_user_email(username)
        setup_test_environment()
        client = Client()
        body = {
            "auth_token": "securitytoken",
            "new_email": "*****@*****.**"
        }
        response = client.post(
            '/email_change',
            data=json.dumps(body),
            content_type='application/json'
        )
        self.assertEqual(response.status_code, 200)

        # Reset back to old email
        body = {
            "auth_token": "securitytoken",
            "new_email": old_email
        }
        response = client.post(
            '/email_change',
            data=json.dumps(body),
            content_type='application/json'
        )
        self.assertEqual(response.status_code, 200)
コード例 #17
0
 def test_health_check_response(self):
     setup_test_environment()
     client = Client()
     response = client.get('/health_check')
     status = json.loads(response.content.decode('utf-8'))
     self.assertEqual(status['isAlive'], True)
     self.assertEqual(response.status_code, 200)
コード例 #18
0
ファイル: web.py プロジェクト: tangerilli/freshen
def use_django(tags=[]):
    
    # "before all"
    log.debug("Setting up django environment")
    from django.test import utils
    from django.db import connection
    from django.test import TestCase
    from django.conf import settings

    old_name = settings.DATABASE_NAME
    utils.setup_test_environment()
    connection.creation.create_test_db(verbosity=0, autoclobber=True)
    
    # Annoyingly, django implements a bunch of methods on the testcase class which don't have
    # anything to do with testcase data, so we have to construct a "proxy" testcase and call
    # methods on it to avoid pasting parts of django here.
    class ProxyTestCase(TestCase):
        def runTest(self):
            pass
    proxy = ProxyTestCase()

    @Before(*tags)
    def set_up(sc):
        proxy._pre_setup()
    
    @After(*tags)
    def tear_down(sc):
        proxy._post_teardown()
    
    # "after all"
    @atexit.register
    def tear_down():
        log.debug("Tearing down django test environment")
        utils.teardown_test_environment()
        connection.creation.destroy_test_db(old_name, verbosity=False)
コード例 #19
0
def main():
    project_dir = dirname(abspath(__file__))

    # setup path
    sys.path.insert(0, project_dir)  # project dir
    sys.path.insert(0, join(project_dir, 'tests'))  # tests dir

    environ['DJANGO_SETTINGS_MODULE'] = 'testapp.settings'

    try:
        # django >= 1.7
        from django import setup
    except ImportError:
        pass
    else:
        setup()

    # setup test env
    from django.test.utils import setup_test_environment
    setup_test_environment()

    # setup db
    from django.core.management import call_command, CommandError
    options = {
        'interactive': False,
        'verbosity': 1,
    }
    try:
        call_command('migrate', **options)
    except CommandError:  # Django < 1.7
        call_command('syncdb', **options)

    # run tests
    return nose.main()
コード例 #20
0
ファイル: plugin.py プロジェクト: danielroseman/pytest_django
    def pytest_sessionstart(self, session):
        setup_test_environment()
        settings.DEBUG = False
        if self.database:
            settings.DATABASE_NAME = self.database

        management.get_commands()
        management._commands["syncdb"] = "django.core"
        if (
            "south" in settings.INSTALLED_APPS
            and hasattr(settings, "SOUTH_TESTS_MIGRATE")
            and settings.SOUTH_TESTS_MIGRATE
        ):
            try:
                from south.management.commands.syncdb import Command
            except ImportError:
                pass
            else:

                class MigrateAndSyncCommand(Command):
                    option_list = Command.option_list
                    for opt in option_list:
                        if "--migrate" == opt.get_opt_string():
                            opt.default = True
                            break

                management._commands["syncdb"] = MigrateAndSyncCommand()

        self._old_database_name = settings.DATABASE_NAME
        create_test_db(self.verbosity, autoclobber=self.noinput, copy_test_db=self.copy_live_db)
コード例 #21
0
 def test_01_full(self):
     self._fixture_teardown()
     teardown_test_environment()
     call_command('test', 'localcrawler')
     call_command('localcrawler')
     setup_test_environment()
     self._fixture_setup()
コード例 #22
0
 def setUp(self):
     setup_test_environment()
     super(IndicatorViewTest, self).setUp()
     self.variable1 = mommy.make(IndicatorVariable)
     self.indicator_criteria = mommy.make(IndicatorVariableCriteria)
     self.form_data = {
                       'name': 'Health',
                       'description': 'some description',
                       'question_set': self.qset.id,
                       'survey': self.survey.id}
     self.variable_data = {
         'name': 'test_variable',
         'validation_test': 'between',
         'description': 'test indicator variable',
         'var_qset': self.qset.id,
         'min': '1',
         'max': '10'
     }
     User.objects.create_user(
         username='******', email='*****@*****.**', password='******')
     self.raj = self.assign_permission_to(User.objects.create_user('demo4', '*****@*****.**', 'demo4'),
                                          'can_view_batches')
     self.assign_permission_to(self.raj, 'can_view_investigators')
     self.assign_permission_to(self.raj, 'can_view_household_groups')
     self.client.login(username='******', password='******')
コード例 #23
0
ファイル: testing.py プロジェクト: mjhea0/app
 def setUp(self):
     #self.patcher1 = patch('testing.original_call',mocked_original_call)
     #self.MockClass1 = self.patcher1.start()
     os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
     from django.test.utils import setup_test_environment
     setup_test_environment()
     pass
コード例 #24
0
ファイル: tests.py プロジェクト: NateWr/rua
 def setUp(self):
     self.client = Client(HTTP_HOST="testing")
     self.user = User.objects.get(pk=1)
     self.user.save()
     setup_test_environment()
     login = self.client.login(username=self.user.username, password="******")
     self.assertEqual(login, True)
コード例 #25
0
ファイル: harvest.py プロジェクト: frac/lettuce
    def handle(self, *args, **options):
        settings.DEBUG = False
        setup_test_environment()

        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)

        paths = self.get_paths(args, apps_to_run, apps_to_avoid)
        if run_server:
            server.start()

        failed = False
        try:
            for path in paths:
                registry.clear()
                result = Runner(path, options.get('scenarios'), verbosity).run()

                if not result or result.steps != result.steps_passed:
                    failed = True

        except Exception, e:
            import traceback
            traceback.print_exc(e)
コード例 #26
0
def before_all(context):
    setup_test_environment()
    context.db_cfg = setup_databases(
        verbosity=False,
        interactive=False,
        keepdb=not context.config.userdata.getbool('RESETDB')
    )
コード例 #27
0
ファイル: views.py プロジェクト: jesspess56/CS169_WarmUp1
def call_unitTests(request):
	from logincounter.tests import UsersModelsTests
	import unittest
	from django.test.utils import setup_test_environment

	setup_test_environment()

	if (request.method =="POST" and request.path=='/TESTAPI/unitTests'):
		content_type = get_content_type(request)
		response_data = {}

		if (content_type == 'application/json'):
			try:
				suite = unittest.TestLoader().loadTestsFromTestCase(UsersModelsTests)
				testing_results = unittest.TextTestRunner(verbosity=2).run(suite)
				response_data['nrFailed'] = len(testing_results.failures)
				response_Data['totalTests'] = testing_results.testRuns
				response_data['output'] = "{}{}".format('\n'.join([result[1] for result in test_results.errors]),'\n'.join([result[1] for result in testing_results.failures]))
			except Exception:
				response_data['nrFailed'] = 0
				response_data['output'] = "Error in running UnitTest"
				response_Data['totalTests'] = 0 
			return HttpResponse(json.dumps(response_data), content_type='application/json')
		else:
			return HttpResponseServerError("Requests invalid in unitTests")
コード例 #28
0
ファイル: djangoplugin.py プロジェクト: dgladkov/tddspry
    def setup_django(self):
        from django.conf import settings

        # If Django < 1.2
        if self.legacy_django:
            from django.db import connection
            from django.test.utils import setup_test_environment

            # Setup Django test environment
            setup_test_environment()

            # Create Django test database
            self.old_database_name = settings.DATABASE_NAME
            connection.creation.create_test_db(self.verbosity,
                                               autoclobber=True)
        # If Django >= 1.2
        else:
            from django.test.simple import DjangoTestSuiteRunner

            # Initialize Django tests runner
            runner = DjangoTestSuiteRunner(interactive=self.interactive,
                                           verbosity=self.verbosity)

            # Setup test environment
            runner.setup_test_environment()

            # Setup test databases
            self.old_config = runner.setup_databases()
            self.runner = runner
コード例 #29
0
    def setUp(self):
        from django.conf import settings
        from django.test.utils import setup_test_environment

        if not settings.configured:
            settings.configure()
        setup_test_environment()
コード例 #30
0
ファイル: conftest.py プロジェクト: pombredanne/twotest
 def setup():
     setup_test_environment()
     if not hasattr(settings, 'DEBUG'):
         settings.DEBUG = False
     from django.db import connection
     connection.creation.create_test_db(verbosity=0, autoclobber=True)
     return Client()
コード例 #31
0
ファイル: run_tests.py プロジェクト: guoyu07/tower-2
#!/usr/bin/env python

import os
import sys

# Set up the environment for our test project.
ROOT = os.path.abspath(os.path.dirname(__file__))

os.environ['DJANGO_SETTINGS_MODULE'] = 'tower-project.settings'
sys.path.insert(0, os.path.join(ROOT, 'examples'))

# This can't be imported until after we've fiddled with the
# environment.
from django.test.utils import setup_test_environment

setup_test_environment()

from django.core.management import call_command

# Run the equivalent of "django-admin.py test"
call_command('test')
コード例 #32
0
ファイル: runner.py プロジェクト: rajankouzina/django
 def setup_test_environment(self, **kwargs):
     setup_test_environment(debug=self.debug_mode)
     unittest.installHandler()
コード例 #33
0
    def __init__(self, parent):
        super(DjangoContext, self).__init__(parent)

        from django.test.utils import setup_test_environment  #, teardown_test_environment

        setup_test_environment()
コード例 #34
0
    def handle(self, *args, **options):
        setup_test_environment()

        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)
        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 Exception as e:
                raise SystemExit(e)

        os.environ['SERVER_NAME'] = str(server.address)
        os.environ['SERVER_PORT'] = str(server.port)

        failed = False

        registry.call_hook('before', 'harvest', locals())
        results = []
        try:
            for path in paths:
                app_module = None
                if isinstance(path, tuple) and len(path) is 2:
                    path, app_module = path

                if app_module is not None:
                    registry.call_hook('before_each', 'app', app_module)

                runner = Runner(path,
                                options.get('scenarios'),
                                verbosity,
                                enable_xunit=options.get('enable_xunit'),
                                enable_subunit=options.get('enable_subunit'),
                                xunit_filename=options.get('xunit_file'),
                                subunit_filename=options.get('subunit_file'),
                                tags=tags,
                                failfast=failfast,
                                auto_pdb=auto_pdb,
                                smtp_queue=smtp_queue)

                result = runner.run()
                if app_module is not None:
                    registry.call_hook('after_each', 'app', app_module, result)

                results.append(result)
                if not result or result.steps != result.steps_passed:
                    failed = True
        except SystemExit as e:
            failed = e.code

        except Exception as e:
            failed = True
            import traceback
            traceback.print_exc(e)

        finally:
            summary = SummaryTotalResults(results)
            summary.summarize_all()
            registry.call_hook('after', 'harvest', summary)

            if test_database:
                self._testrunner.teardown_databases(self._old_db_config)

            teardown_test_environment()
            server.stop(failed)

            raise SystemExit(int(failed))
コード例 #35
0
 def setup_test_environment(self, **kwargs):
     setup_test_environment()
     settings.DEBUG = False
コード例 #36
0
        '''
        was_published_recently() returns True for questions whose pub_date
        is within the last day.
        '''
        time = timezone.now() - datetime.timedelta(
            hours=23, minutes=59, seconds=59
        )
        recent_question = Question(pub_date=time)
        self.assertIs(recent_question.was_published_recently(), True)

# Use the shell to test a view ------------------------------------------------

# Command Line
py manage.py test polls
>>> from django.test.utils import setup_test_environment
>>> setup_test_environment()
>>> from django.test import Client
>>> client = Client()
>>> response = client.get('/')
>>> response.status_code                                    # Should be 404
>>> from django.urls import reverse
>>> response = client.get(reverse('polls:index'))
>>> response.status_code                                    # Should be 200
>>> response.content
>>> response.context['latest_question_list']

# Update the Index View to exclude future questions & create tests ------------

# /mysite/polls/views.py (Show only past questions)
...
from django.utils import timezone
コード例 #37
0
 def test_setup_test_environment_calling_more_than_once(self):
     with self.assertRaisesMessage(
             RuntimeError, "setup_test_environment() was already called"):
         setup_test_environment()
コード例 #38
0
def run_tests(verbosity=1, interactive=False):
    from django.conf import settings
    from django.core import management
    from django.db import connection
    from django.test.utils import (setup_test_environment,
                                   teardown_test_environment)

    try:
        from django import setup

        # Django >= 1.7
        setup()
        use_migrations = True
    except ImportError:
        # Django < 1.7
        use_migrations = False

    # Restore warnings, if Django turns them off.
    warnings.simplefilter('default')

    setup_test_environment()
    settings.DEBUG = False

    for path in (settings.MEDIA_ROOT, settings.STATIC_ROOT):
        if not os.path.exists(path):
            os.mkdir(path, 0o755)

    old_db_name = 'default'
    connection.creation.create_test_db(verbosity, autoclobber=not interactive)

    if use_migrations:
        management.call_command('migrate',
                                use_syncdb=True,
                                verbosity=verbosity,
                                interactive=interactive)
    else:
        management.call_command('syncdb',
                                verbosity=verbosity,
                                interactive=interactive)

    nose_argv = [
        'runtests.py',
        '-v',
        '--match=^test',
        '--with-id',
    ]

    if '--with-coverage' in sys.argv:
        sys.argv.remove('--with-coverage')
        nose_argv += [
            '--with-coverage',
            '--cover-inclusive',
            '--cover-package=djblets',
        ]

    nose_argv += sys.argv[1:]

    # If the test files are executable on the file system, nose will need the
    #  --exe argument to run them
    known_file = os.path.join(os.path.dirname(__file__), '..', 'djblets',
                              'settings.py')

    if (os.path.exists(known_file)
            and os.stat(known_file).st_mode & stat.S_IXUSR):
        nose_argv.append('--exe')

    nose.main(argv=nose_argv)

    connection.creation.destroy_test_db(old_db_name, verbosity)
    teardown_test_environment()
コード例 #39
0
 def __init__(self, methodName='runTest'):
     TestCase.__init__(self, methodName=methodName)
     setup_test_environment()
     self.client = Client()
コード例 #40
0
ファイル: runtests.py プロジェクト: jinchaoh/Misago
def runtests():
    test_runner_path = os.path.dirname(__file__)
    project_template_path = os.path.join(
        test_runner_path, 'misago/project_template/project_name')
    avatars_store_path = os.path.join(test_runner_path,
                                      'misago/project_template/avatar_store')
    media_path = os.path.join(test_runner_path,
                              'misago/project_template/media')

    test_project_path = os.path.join(test_runner_path, "testproject")
    test_project_avatars_path = os.path.join(test_runner_path, "avatar_store")
    test_project_media_path = os.path.join(test_runner_path, "media")
    if not os.path.exists(test_project_path):
        shutil.copytree(project_template_path, test_project_path)
        shutil.copytree(avatars_store_path, test_project_avatars_path)
        shutil.copytree(media_path, test_project_media_path)

        settings_path = os.path.join(test_project_path, "settings.py")
        with open(settings_path, "r") as py_file:
            settings_file = py_file.read()

            # Do some configuration magic
            settings_file = settings_file.replace("{{ project_name }}",
                                                  "testproject")
            settings_file = settings_file.replace("{{ secret_key }}",
                                                  "t3stpr0j3ct")
            settings_file += """
MISAGO_NEW_REGISTRATIONS_VALIDATORS = ()

EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'uniqu3-sn0wf14k3'
    }
}
"""

        if os.environ.get('TRAVIS'):
            settings_file += """

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'travis_ci_test',
        'USER': '******',
        'PASSWORD': '',
        'HOST': '127.0.0.1',
        'PORT': '',
    }
}

TEST_NAME = 'travis_ci_test'
"""
        else:
            settings_file += """
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'misago_postgres',
        'USER': '******',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '',
    }
}
""" % pwd.getpwuid(os.getuid())[0]

        with open(settings_path, "w") as py_file:
            py_file.write(settings_file)

    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testproject.settings")

    setup()
    setup_test_environment()

    if __name__ == '__main__':
        args = sys.argv[1:]
    else:
        args = []

    from django.core.management.commands import test
    sys.exit(test.Command().execute(*args, verbosity=1))
コード例 #41
0
 def setUp(self):
     setup_test_environment(debug=True)
     self.api_document = APIDocument()
     self.client = doc_client(self.api_document, self.client)
コード例 #42
0
    def handle(self, *args, **options):
        setup_test_environment()

        verbosity = options['verbosity']
        no_color = options.get('no_color', False)
        apps_to_run = tuple(options['apps'].split(","))
        apps_to_avoid = tuple(options['avoid_apps'].split(","))
        run_server = not options['no_server']
        test_database = options['test_database']
        smtp_queue = options['smtp_queue']
        tags = options['tags']
        failfast = options['failfast']
        auto_pdb = options['auto_pdb']
        threading = options['use_threading']

        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()

            if DJANGO_VERSION < StrictVersion('1.7'):
                call_command(
                    'syncdb',
                    verbosity=0,
                    interactive=False,
                )
                if migrate_south:
                    call_command(
                        'migrate',
                        verbosity=0,
                        interactive=False,
                    )
            else:
                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 as e:
                raise CommandError("Couldn't start Django server: %s" % e)

        os.environ['SERVER_NAME'] = str(server.address)
        os.environ['SERVER_PORT'] = str(server.port)

        failed = False

        registry.call_hook('before', 'harvest', locals())
        results = []
        try:
            for path in paths:
                app_module = None
                if isinstance(path, tuple) and len(path) is 2:
                    path, app_module = path

                if app_module is not None:
                    registry.call_hook('before_each', 'app', app_module)

                runner = Runner(
                    path,
                    options.get('scenarios'),
                    verbosity,
                    no_color,
                    enable_xunit=options.get('enable_xunit'),
                    enable_subunit=options.get('enable_subunit'),
                    enable_jsonreport=options.get('enable_jsonreport'),
                    xunit_filename=options.get('xunit_file'),
                    subunit_filename=options.get('subunit_file'),
                    jsonreport_filename=options.get('jsonreport_file'),
                    tags=tags,
                    failfast=failfast,
                    auto_pdb=auto_pdb,
                    smtp_queue=smtp_queue)

                result = runner.run()
                if app_module is not None:
                    registry.call_hook('after_each', 'app', app_module, result)

                results.append(result)
                if not result or result.steps != result.steps_passed:
                    failed = True
        except LettuceRunnerError:
            failed = True

        except Exception as e:
            failed = True
            traceback.print_exc(e)

        finally:
            summary = SummaryTotalResults(results)
            summary.summarize_all()
            registry.call_hook('after', 'harvest', summary)

            if test_database:
                self._testrunner.teardown_databases(self._old_db_config)

            teardown_test_environment()
            server.stop(failed)

            if failed:
                raise CommandError("Lettuce tests failed.")
コード例 #43
0
def pytest_configure(config):
    if django.VERSION >= (1, 7):
        django.setup()
    setup_test_environment()
    connection.creation.create_test_db(verbosity=2, autoclobber=True)
コード例 #44
0
def setup_package(module):
    utils.setup_test_environment()
    module._old_db_name = connection.creation.create_test_db(verbosity=1)
コード例 #45
0
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
    """
    worsk exactly as per normal test
    but only creates the test_db if it doesn't yet exist
    and does not destroy it when done
    tables are flushed and fixtures loaded between tests as per usual
    but if your schema has not changed then this saves significant amounts of time
    and speeds up the test cycle

    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.

    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.addTest(build_test(label))
            else:
                app = apps.get_app(label)
                suite.addTest(build_suite(app))
    else:
        for app in apps.get_apps():
            suite.addTest(build_suite(app))

    for test in extra_tests:
        suite.addTest(test)

    suite = reorder_suite(suite, (TestCase, ))

    old_name = settings.DATABASES['default']['NAME']

    # Everything up to here is from django.test.simple

    from django.db.backends import creation
    from django.db import connection, DatabaseError

    if settings.DATABASES['default']['TEST_NAME']:
        settings.DATABASES['default']['NAME'] = settings.DATABASES['default'][
            'TEST_NAME']
    else:
        settings.DATABASES['default'][
            'NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES[
                'default']['NAME']
    connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default'][
        'NAME']

    # does test db exist already ?
    try:
        if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
            if not os.path.exists(settings.DATABASES['default']['NAME']):
                raise DatabaseError
        cursor = connection.cursor()
    except Exception:
        # db does not exist
        # juggling !  create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
        settings.DATABASES['default']['NAME'] = old_name
        connection.settings_dict["DATABASE_NAME"] = old_name
        connection.creation.create_test_db(verbosity, autoclobber=True)
    else:
        connection.close()

    settings.DATABASES['default'][
        'SUPPORTS_TRANSACTIONS'] = connections_support_transactions()

    result = unittest.TextTestRunner(verbosity=verbosity).run(suite)

    # Since we don't call destory_test_db, we need to set the db name back.
    settings.DATABASES['default']['NAME'] = old_name
    connection.settings_dict["DATABASE_NAME"] = old_name
    teardown_test_environment()

    return len(result.failures) + len(result.errors)
コード例 #46
0
 def setUp(self):
     super().setUp()
     setup_test_environment()
     _django_instrumentor.instrument()
     Configuration._reset()  # pylint: disable=protected-access
コード例 #47
0
ファイル: djangotestrunner.py プロジェクト: qafro1/xmlrunner
 def setup_test_environment(self, **kwargs):
     setup_test_environment()
コード例 #48
0
def setup_module():
    utils.setup_test_environment()
コード例 #49
0
 def begin(self):
     from django.test.utils import setup_test_environment
     setup_test_environment()
コード例 #50
0
    def run_suite(self, nose_argv=None):
        """Test runner that invokes nose."""
        # Prepare django for testing.
        from django.conf import settings
        utils.setup_test_environment()
        old_db_name = settings.DATABASE_NAME

        result_plugin = ResultPlugin()
        plugins = [
            DjangoPlugin(),
            SeleniumPlugin(),
            DjangoTranslationPlugin(), result_plugin
        ]

        if getattr(settings, 'CHERRYPY_TEST_SERVER', False):
            plugins.append(CherryPyLiveServerPlugin())
        else:
            plugins.append(DjangoLiveServerPlugin())

        # Do not pretend it's a production environment.
        # settings.DEBUG = False

        # We pass nose a list of arguments that looks like sys.argv, but customize
        # to avoid unknown django arguments.

        for plugin in _get_plugins_from_settings():
            plugins_to_add.append(plugin)
        # activate all required plugins
        activate_plugin(DjangoPlugin, nose_argv)
        activate_plugin(SeleniumPlugin, nose_argv)
        activate_plugin(DjangoTranslationPlugin, nose_argv)
        #    activate_plugin(ResultPlugin, nose_argv)

        if getattr(settings, 'CHERRYPY_TEST_SERVER', False):
            activate_plugin(CherryPyLiveServerPlugin, nose_argv)
        else:
            activate_plugin(DjangoLiveServerPlugin, nose_argv)

        # Skip over 'manage.py test' and any arguments handled by django.
        django_opts = ['--noinput']
        for opt in BaseCommand.option_list:
            django_opts.extend(opt._long_opts)
            django_opts.extend(opt._short_opts)

        nose_argv.extend(
            OPTION_TRANSLATION.get(opt, opt) for opt in sys.argv[1:]
            if opt.startswith('-') and not any(
                opt.startswith(d) for d in django_opts))

        if self.verbosity >= 2:
            print ' '.join(nose_argv)

        test_program = nose.core.TestProgram(argv=nose_argv,
                                             exit=False,
                                             addplugins=plugins)

        # FIXME: ResultPlugin is working not exactly as advertised in django-nose
        # multiple instance problem, find workaround
        #    result = result_plugin.result
        #    return len(result.failures) + len(result.errors)
        return not test_program.success
コード例 #51
0
 def setUp(self):
     setup_test_environment()
コード例 #52
0
ファイル: runner.py プロジェクト: dadizhimai/i9670-django1
 def setup_test_environment(self, **kwargs):
     setup_test_environment()
     settings.DEBUG = False
     unittest.installHandler()
コード例 #53
0
ファイル: __init__.py プロジェクト: Shrews/PyGerrit
def run_tests(test_labels,
              verbosity=1,
              interactive=True,
              extra_tests=[],
              suite=None):
    """
    This module allows users to run tests for GIS apps that require the creation 
    of a spatial database.  Currently, this is only required for PostgreSQL as
    PostGIS needs extra overhead in test database creation.

    In order to create a PostGIS database, the DATABASE_USER (or 
    TEST_DATABASE_USER, if defined) will require superuser priviliges.  

    To accomplish this outside the `postgres` user, you have a few options:
      (A) Make your user a super user:
        This may be done at the time the user is created, for example:
        $ createuser --superuser <user_name>

        Or you may alter the user's role from the SQL shell (assuming this
        is done from an existing superuser role):
        postgres# ALTER ROLE <user_name> SUPERUSER;

      (B) Create your own PostgreSQL database as a local user:
        1. Initialize database: `initdb -D /path/to/user/db`
        2. If there's already a Postgres instance on the machine, it will need
           to use a different TCP port than 5432. Edit postgresql.conf (in 
           /path/to/user/db) to change the database port (e.g. `port = 5433`).  
        3. Start this database `pg_ctl -D /path/to/user/db start`

      (C) On Windows platforms the pgAdmin III utility may also be used as 
        a simple way to add superuser privileges to your database user.

    The TEST_RUNNER needs to be set in your settings like so:

      TEST_RUNNER='django.contrib.gis.tests.run_tests'

    Note: This test runner assumes that the PostGIS SQL files ('lwpostgis.sql'
    and 'spatial_ref_sys.sql') are installed in the directory specified by 
    `pg_config --sharedir` (and defaults to /usr/local/share if that fails).
    This behavior is overridden if POSTGIS_SQL_PATH is set in your settings.
    
    Windows users should set POSTGIS_SQL_PATH manually because the output
    of `pg_config` uses paths like 'C:/PROGRA~1/POSTGR~1/..'.

    Finally, the tests may be run by invoking `./manage.py test`.
    """
    # The `create_spatial_db` routine abstracts away all the steps needed
    # to properly construct a spatial database for the backend.
    from django.contrib.gis.db.backend import create_spatial_db

    # Setting up for testing.
    setup_test_environment()
    settings.DEBUG = False
    old_name = settings.DATABASE_NAME

    # The suite may be passed in manually, e.g., when we run the GeoDjango test,
    # we want to build it and pass it in due to some customizations.  Otherwise,
    # the normal test suite creation process from `django.test.simple.run_tests`
    # is used to create the test suite.
    if suite is None:
        suite = unittest.TestSuite()
        if test_labels:
            for label in test_labels:
                if '.' in label:
                    suite.addTest(build_test(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)

    # Creating the test spatial database.
    create_spatial_db(test=True, verbosity=verbosity)

    # Executing the tests (including the model tests), and destorying the
    # test database after the tests have completed.
    result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
    connection.creation.destroy_test_db(old_name, verbosity)
    teardown_test_environment()

    # Returning the total failures and errors
    return len(result.failures) + len(result.errors)
コード例 #54
0
def setUpModule():
    django_test_utils.setup_test_environment()
    runner_state = django_test_utils.setup_databases(verbosity=0,
                                                     interactive=False)
    test_state['runner_state'] = runner_state
コード例 #55
0
 def setUp(self):
     super().setUp()
     setup_test_environment()
     _django_instrumentor.instrument()
コード例 #56
0
 def setup_test_environment(self):
     setup_test_environment()
     settings.DEBUG = False
コード例 #57
0
ファイル: __init__.py プロジェクト: TimNN/opensubmit
 def setup_test_environment(self, **kwargs):
     os.environ['DJANGO_LIVE_TEST_SERVER_ADDRESS'] = TEST_HOST
     setup_test_environment()
     settings.DEBUG = True
     unittest.installHandler()
コード例 #58
0
ファイル: test_views.py プロジェクト: mtgorski/tic_tac_toe
 def setup_client(self):
     self.client = Client()
     setup_test_environment()
コード例 #59
0
 def pre_test(self):
     dutils.setup_test_environment()
     old_conf = dutils.setup_databases(1, False, aliases='default')
     self.start_app_threat()
     self._wait_for_live_app()
     return old_conf
コード例 #60
0
ファイル: run_task.py プロジェクト: jdrew1303/accountifie
    def handle(self, **options):
        taskName = options['task']
        if not taskName:
            raise ValueError('required argument --task not specified')
        async = options['async']

        if async:
            D = Detacher()
            if sys.platform == 'win32':
                if not options['detached']:
                    D.detach()
            else:
                D.detach()

            #if we're here we should be fully detached
        #if --task-testing was passed we use a test setup
        if options['testing']:
            from django.test.utils import setup_test_environment
            setup_test_environment()
        pid = os.getpid()
        logs = os.path.join(settings.ENVIRON_DIR, 'logs')
        if not os.path.isdir(logs):
            os.makedirs(logs)
        log = IdentiFile(open(os.path.join(logs, 'deferredtasks.out'), 'a'),
                         '%-5d' % pid)
        success = False
        print >> log, '##### task %s[%-5d] started' % (taskName, pid)
        try:
            if options['log_std']:
                #debug version everything get's written to the logfile as well
                class StringIOX(StringIO):
                    def write(self, s):
                        log.write(s)
                        StringIO.write(self, s)

                sys_stdout = StringIOX()
                sys_stderr = StringIOX()
            else:
                sys_stdout = StringIO()
                sys_stderr = StringIO()
            if not async:
                old_stdout = sys.stdout
                old_stderr = sys.stderr
            sys.stdout = sys_stdout
            sys.stderr = sys_stderr
            dtask = DeferredTask()
            dtask.start = utcnow()
            dtask.pid = pid
            dtask.progress = 0
            username = options.get('username', '')
            dtask.username = decode(username) if username else ''
            dtask.status = 'initialized'

            # reset DB connection which might have been killed in detachment process
            # but close_connection deprecated in Django 1.8
            # seems to be working OK without this
            #db.close_connection()

            dtask.save()
            D = {}
            dtask.task = taskName
            dtask.save()
            exec 'from %s import %s as task' % tuple(taskName.rsplit('.',
                                                                     1)) in D
            task = D['task']
            args = options.get('args', ())
            if args: args = decode(args)
            kwds = options.get('kwds', {})
            if kwds: kwds = decode(kwds)
            _success_url = kwds.pop('task_success_url', False)
            dtask.success_url = ''
            if _success_url and not '?pid=' in _success_url:
                if '?' in _success_url:
                    dtask.success_url = "%s&pid=%s" % (_success_url, dtask.pid)
                else:
                    dtask.success_url = "%s?pid=%s" % (_success_url, dtask.pid)
            dtask.args = repr(args)
            dtask.kwds = repr(kwds)
            dtask.hashcode = hashFunc(taskName, args, kwds)
            dtask.title = kwds.pop('task_title', '')
            dtask.status = 'prepared'
            dtask.save()
            result = getattr(task, '_task_func', task)(*args, **kwds)
            dtask = DeferredTask.objects.get(pid=pid)
            dtask.result = result
            dtask.status = 'finished'
            dtask.progress = 100
            dtask.save()
            success = True
        except:
            traceback.print_exc()
            traceback.print_exc(file=log)
        finally:
            try:
                dtask = DeferredTask.objects.get(pid=pid)
                dtask.success = success
                dtask.finished = True
                dtask.status = 'suceeded' if success else 'failed'
                dtask.finish = utcnow()
                dtask.stdout = sys_stdout.getvalue()
                dtask.stderr = sys_stderr.getvalue()
                dtask.save()
                print >> log, '%s task %s[%-5d] %s' % (
                    ('!!!!!', '#####')[success], taskName, pid,
                    ('failed!', 'ended OK.')[success])
            except:
                traceback.print_exc(file=log)
            finally:
                if not async:
                    sys.stdout = old_stdout
                    sys.stderr = old_stderr