Example #1
0
    def get_test_labels(cls, tests):
        """Get a list of app labels and possibly tests for the db app optimizer

        This should be called after `loadTestsFromNames` has been called.
        """
        test_apps = set(app.name for app in apps.get_app_configs()
                        if app.name not in settings.APPS_TO_EXCLUDE_FROM_TESTS
                        and not app.name.startswith('django.'))
        if not cls.user_specified_test_names:
            return [AppConfig.create(app).label for app in test_apps]

        def iter_names(test):
            # a.b.c -> a.b.c, a.b, a
            if isinstance(test.context, type):
                name = test.context.__module__
            elif isinstance(test.context, types.ModuleType):
                name = test.context.__name__
            else:
                raise RuntimeError("unknown test type: {!r}".format(test))
            parts = name.split(".")
            num_parts = len(parts)
            for i in range(num_parts):
                yield ".".join(parts[:num_parts - i])

        labels = set()
        for test in tests:
            for name in iter_names(test):
                if name in test_apps:
                    labels.add((AppConfig.create(name).label, test.context))
                    break
        return list(labels)
Example #2
0
    def ready(self):

        from .models import MeetingInteraction, PhoneInteraction
        from .signals.handlers import set_attendees_string

        m2m_changed.connect(
            set_attendees_string, sender=PhoneInteraction.attendees.through)
        m2m_changed.connect(
            set_attendees_string, sender=MeetingInteraction.attendees.through)

        AppConfig.ready(self)
Example #3
0
    def ready(self):

        from .signals import document_consumption_finished
        from .signals.handlers import (
            set_correspondent, set_tags, run_external_script)

        document_consumption_finished.connect(set_tags)
        document_consumption_finished.connect(set_correspondent)
        document_consumption_finished.connect(run_external_script)

        AppConfig.ready(self)
    def ready(self):
        if self.ready_run:
            return
        self.ready_run = True

        try:
            functionList = inspect.getmembers(analytics_automated.validators,
                                              inspect.isfunction)
            validatorList = [seq[0] for seq in functionList]
            validator_types = AppConfig.get_model(self, "ValidatorTypes")
            existing_entries = validator_types.objects.all().values_list('name')

            existing_types = [seq[0] for seq in existing_entries]
            for this_type in existing_types:
                print("Existing validator: "+str(this_type))
                if this_type not in validatorList:
                    print("Removing removed validator: "+this_type)
                    validator_types.objects.filter(name=this_type).delete()

            for validator in validatorList:
                if validator not in existing_types and \
                  not validator.startswith("_"):
                    print("Registering New Validator Type: "+validator)
                    validator_types.objects.create(name=validator)
        except:
            print("First time eh?")
Example #5
0
 def test_import_error(self):
     "Test for #12658 - Tests with ImportError's shouldn't fail silently"
     from django.apps import AppConfig
     from django.test.simple import get_tests
     app_config = AppConfig.create('test_runner_invalid_app')
     app_config.import_models({})
     with self.assertRaises(ImportError):
         get_tests(app_config)
Example #6
0
 def test_get_tests(self):
     "Check that the get_tests helper function can find tests in a directory"
     from django.apps import AppConfig
     from django.test.simple import get_tests
     app_config = AppConfig.create('test_runner.valid_app')
     app_config.import_models({})
     tests = get_tests(app_config)
     self.assertIsInstance(tests, types.ModuleType)
 def test_overriding_view_is_possible_without_overriding_app(self):
     # If test fails, it's helpful to know if it's caused by order of
     # execution
     customer_app_config = AppConfig.create('oscar.apps.customer')
     customer_app_config.ready()
     self.assertEqual(customer_app_config.summary_view.__module__,
                      'tests._site.apps.customer.views')
     self.assertEqual(apps.get_app_config('customer').summary_view.__module__,
                      'tests._site.apps.customer.views')
def app_labels(apps_list):
    """
    Returns a list of app labels of the given apps_list, now properly handles
     new Django 1.7+ application registry.

    https://docs.djangoproject.com/en/1.8/ref/applications/#django.apps.AppConfig.label
    """
    if AppConfig is None:
        return [app.split('.')[-1] for app in apps_list]
    return [AppConfig.create(app).label for app in apps_list]
def post_migrate_tags(sender: AppConfig, **kwargs):
    Tag = sender.get_model("Tag")
    for data in TAGS:
        if not Tag.objects.filter(color=data['color']).exists():
            Tag.objects.create(**data)
Example #10
0
from django.apps import AppConfig


class {{ cookiecutter.project_slug.title().replace('_', '') }}AppConfig(AppConfig):
    name = '{{ cookiecutter.project_slug }}'

    def ready(self):
        # noinspection PyUnresolvedReferences
        from {{ cookiecutter.project_slug }} import celery  # noqa
Example #11
0
 def __init__(self, app_name, app_module):
     AppConfig.__init__(self, app_name, app_module)
     local_settings.APP_PATH = self.path
Example #12
0
 def ready(self):
     import hotel.signals
     AppConfig.ready(self)
Example #13
0
def get_first_party_app_labels() -> set[str] | None:
    if not settings.is_overridden("FIRST_PARTY_APPS"):
        return None
    return {AppConfig.create(name).label for name in settings.FIRST_PARTY_APPS}
Example #14
0
 def ready(self):
     AppConfig.ready(self)
Example #15
0
 def test_no_dunder_path_or_dunder_file(self):
     """If there is no __path__ or __file__, raise ImproperlyConfigured."""
     with self.assertRaises(ImproperlyConfigured):
         AppConfig('label', Stub())
Example #16
0
 def test_multiple_dunder_path_no_dunder_file(self):
     """If the __path__ attr is length>1 and there is no __file__, raise."""
     with self.assertRaises(ImproperlyConfigured):
         AppConfig('label', Stub(__path__=['a', 'b']))
Example #17
0
 def setUp(self):
     super(CredentialsConfigTests, self).setUp()
     self.app_config = AppConfig.create('credentials.apps.credentials')
Example #18
0
    def test_empty_dunder_path_fallback_to_dunder_file(self):
        """If the __path__ attr is empty, use __file__ if set."""
        ac = AppConfig('label', Stub(__path__=[], __file__='b/__init__.py'))

        self.assertEqual(ac.path, 'b')
def test_default_config_exists():
    """
    A really trivial "test case": just checking that the app can be instantiated.
    """
    app = AppConfig.create("morphodict.apps.MorphodictConfig")
    assert "morphodict" in app.name
def post_migrate_modules(sender: AppConfig, **kwargs):
    if sender.name + "_module" in connection.introspection.table_names():
        Module = sender.get_model('Module')
        for kw in data:
            if not Module.objects.filter(name=kw["name"]).exists():
                Module.objects.create(**kw)
Example #21
0
 def ready(self):
     from user.receivers import SignalReceiver
     SignalReceiver.connect()
     AppConfig.ready(self)
Example #22
0
def _ready(self):
    return _APPCFG.ready(self)
Example #23
0
 def ready(self):
     import djreservation.signals
     AppConfig.ready(self)
Example #24
0
    def test_multiple_dunder_path_fallback_to_dunder_file(self):
        """If the __path__ attr is length>1, use __file__ if set."""
        ac = AppConfig('label',
                       Stub(__path__=['a', 'b'], __file__='c/__init__.py'))

        self.assertEqual(ac.path, 'c')
 def ready(self):
     AppConfig.ready(self)
     from book_store import signals
Example #26
0
 def test_empty_dunder_path_no_dunder_file(self):
     """If the __path__ attr is empty and there is no __file__, raise."""
     with self.assertRaises(ImproperlyConfigured):
         AppConfig('label', Stub(__path__=[]))
Example #27
0
urlpatterns += redirect_urlpatterns()


def remove_prefix(appname, prefix="omero_"):
    if appname.startswith(prefix):
        return appname[len(prefix):]
    return appname

for app in settings.ADDITIONAL_APPS:
    if django.VERSION > (1, 7):
        from django.apps import AppConfig
        if isinstance(app, AppConfig):
            app_config = app
        else:
            app_config = AppConfig.create(app)
        label = app_config.label
    else:
        logger.warn(
            ("Django %s does not support AppConfig. Some OMERO.web plugins "
             "may not work correctly.") % django.get_version())
        label = remove_prefix(app)
    # Depending on how we added the app to INSTALLED_APPS in settings.py,
    # include the urls the same way
    if 'omeroweb.%s' % app in settings.INSTALLED_APPS:
        urlmodule = 'omeroweb.%s.urls' % app
    else:
        urlmodule = '%s.urls' % app
    try:
        __import__(urlmodule)
    except ImportError:
Example #28
0
from django.apps import AppConfig


class Wagtail{{ cookiecutter.project_name_camel }}AppConfig(AppConfig):
    label = "wagtail_{{ cookiecutter.project_name_snake }}"
    name = "wagtail_{{ cookiecutter.project_name_snake }}"
    verbose_name = "Wagtail {{ cookiecutter.project_name }}"
Example #29
0
    def ready(self):
        from documents.signals import document_consumer_declaration

        if settings.PAPERLESS_TIKA_ENABLED:
            document_consumer_declaration.connect(tika_consumer_declaration)
        AppConfig.ready(self)
Example #30
0
 def ready(self):
     AppConfig.ready(self)
     init_session()
     g.version = str(uuid.uuid4()).replace('-', '')
Example #31
0
def _ready(self):
    from . import signals
    return _APPCFG.ready(self)
Example #32
0
def add_post(request):
    postInfo = AppConfig.get_model(Posts, required_ready=True)
    form = postInfo(request.POST)
    print("requestpost", request.POST)
    form.save()
Example #33
0
def setup(verbosity, test_labels):
    import django
    from django.apps import apps, AppConfig
    from django.conf import settings
    from django.test import TransactionTestCase, TestCase

    print("Testing against Django installed in '%s'" % os.path.dirname(django.__file__))

    # Force declaring available_apps in TransactionTestCase for faster tests.
    def no_available_apps(self):
        raise Exception("Please define available_apps in TransactionTestCase "
                        "and its subclasses.")
    TransactionTestCase.available_apps = property(no_available_apps)
    TestCase.available_apps = None

    state = {
        'INSTALLED_APPS': settings.INSTALLED_APPS,
        'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""),
        'TEMPLATE_DIRS': settings.TEMPLATE_DIRS,
        'LANGUAGE_CODE': settings.LANGUAGE_CODE,
        'STATIC_URL': settings.STATIC_URL,
        'STATIC_ROOT': settings.STATIC_ROOT,
    }

    # Redirect some settings for the duration of these tests.
    settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
    settings.ROOT_URLCONF = 'urls'
    settings.STATIC_URL = '/static/'
    settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static')
    settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR),)
    settings.LANGUAGE_CODE = 'en'
    settings.SITE_ID = 1

    if verbosity > 0:
        # Ensure any warnings captured to logging are piped through a verbose
        # logging handler.  If any -W options were passed explicitly on command
        # line, warnings are not captured, and this has no effect.
        logger = logging.getLogger('py.warnings')
        handler = logging.StreamHandler()
        logger.addHandler(handler)

    # Load all the ALWAYS_INSTALLED_APPS.
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore', 'django.contrib.comments is deprecated and will be removed before Django 1.8.', DeprecationWarning)
        apps.populate_models()

    # Load all the test model apps.
    test_modules = get_test_modules()

    # Reduce given test labels to just the app module path
    test_labels_set = set()
    for label in test_labels:
        bits = label.split('.')
        if bits[:2] == ['django', 'contrib']:
            bits = bits[:3]
        else:
            bits = bits[:1]
        test_labels_set.add('.'.join(bits))

    for modpath, module_name in test_modules:
        if modpath:
            module_label = '.'.join([modpath, module_name])
        else:
            module_label = module_name
        # if the module (or an ancestor) was named on the command line, or
        # no modules were named (i.e., run all), import
        # this module and add it to INSTALLED_APPS.
        if not test_labels:
            module_found_in_labels = True
        else:
            match = lambda label: (
                module_label == label or  # exact match
                module_label.startswith(label + '.')  # ancestor match
            )

            module_found_in_labels = any(match(l) for l in test_labels_set)

        if module_found_in_labels:
            if verbosity >= 2:
                print("Importing application %s" % module_name)
            # HACK.
            if module_label not in settings.INSTALLED_APPS:
                settings.INSTALLED_APPS.append(module_label)
            app_config = AppConfig.create(module_label)
            app_config.import_models(apps.all_models[app_config.label])
            apps.app_configs[app_config.label] = app_config
            apps.get_models.cache_clear()

    return state
Example #34
0
 def setUp(self):
     super(CredentialsConfigTests, self).setUp()
     self.app_config = AppConfig.create('credentials.apps.credentials')
def setup(verbosity, test_labels):
    state = {
        'INSTALLED_APPS': settings.INSTALLED_APPS,
        'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""),
        'TEMPLATE_DIRS': settings.TEMPLATE_DIRS,
        'LANGUAGE_CODE': settings.LANGUAGE_CODE,
        'STATIC_URL': settings.STATIC_URL,
        'STATIC_ROOT': settings.STATIC_ROOT,
        'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES,
    }

    settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
    settings.ROOT_URLCONF = 'denyzen.tests.urls'
    settings.STATIC_URL = '/static/'
    settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static')
    settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR),)
    settings.LANGUAGE_CODE = 'en'
    settings.SITE_ID = 1
    settings.MIDDLEWARE_CLASSES = ALWAYS_MIDDLEWARE_CLASSES
    # Ensure the middleware classes are seen as overridden otherwise we get a compatibility warning.
    #settings._explicit_settings.add('MIDDLEWARE_CLASSES')
    settings.MIGRATION_MODULES = {
        # these 'tests.migrations' modules don't actually exist, but this lets
        # us skip creating migrations for the test models.
        'auth': 'django.contrib.auth.tests.migrations',
        'contenttypes': 'django.contrib.contenttypes.tests.migrations',
    }

    # Load all the ALWAYS_INSTALLED_APPS.
    django.setup()

    if verbosity > 0:
        # Ensure any warnings captured to logging are piped through a verbose
        # logging handler.  If any -W options were passed explicitly on command
        # line, warnings are not captured, and this has no effect.
        logger = logging.getLogger('py.warnings')
        handler = logging.StreamHandler()
        logger.addHandler(handler)

    # Load all the test model apps.
    test_modules = get_test_modules()
    print(test_modules)

    test_labels_set = set()
    for label in test_labels:
        test_labels_set.add(label)

    installed_app_names = set(get_installed())
    for modpath, module_name in test_modules:
        if modpath:
            module_label = '.'.join([modpath, module_name])
        else:
            module_label = module_name
        # if the module (or an ancestor) was named on the command line, or
        # no modules were named (i.e., run all), import
        # this module and add it to INSTALLED_APPS.
        if not test_labels:
            module_found_in_labels = True
        else:
            module_found_in_labels = any(
                # exact match or ancestor match
                module_label == label or module_label.startswith(label + '.')
                for label in test_labels_set)

        if module_found_in_labels and module_label not in installed_app_names:
            if verbosity >= 2:
                print("Importing application %s" % module_name)
            settings.INSTALLED_APPS.append(module_label)
            app_config = AppConfig.create(module_name)
            apps.app_configs[app_config.label] = app_config
            app_config.import_models(apps.all_models[app_config.label])
            apps.clear_cache()

    apps.set_installed_apps(settings.INSTALLED_APPS)

    return state
Example #36
0
def setup(verbosity, test_labels):
    from django.apps import apps, AppConfig
    from django.conf import settings
    from django.test import TransactionTestCase, TestCase

    print("Testing against Django installed in '%s'" %
          os.path.dirname(django.__file__))

    # Force declaring available_apps in TransactionTestCase for faster tests.
    def no_available_apps(self):
        raise Exception("Please define available_apps in TransactionTestCase "
                        "and its subclasses.")

    TransactionTestCase.available_apps = property(no_available_apps)
    TestCase.available_apps = None

    state = {
        'INSTALLED_APPS': settings.INSTALLED_APPS,
        'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""),
        'TEMPLATE_DIRS': settings.TEMPLATE_DIRS,
        'LANGUAGE_CODE': settings.LANGUAGE_CODE,
        'STATIC_URL': settings.STATIC_URL,
        'STATIC_ROOT': settings.STATIC_ROOT,
    }

    # Redirect some settings for the duration of these tests.
    settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
    settings.ROOT_URLCONF = 'urls'
    settings.STATIC_URL = '/static/'
    settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static')
    settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR), )
    settings.LANGUAGE_CODE = 'en'
    settings.SITE_ID = 1

    if verbosity > 0:
        # Ensure any warnings captured to logging are piped through a verbose
        # logging handler.  If any -W options were passed explicitly on command
        # line, warnings are not captured, and this has no effect.
        logger = logging.getLogger('py.warnings')
        handler = logging.StreamHandler()
        logger.addHandler(handler)

    warnings.filterwarnings(
        'ignore',
        'django.contrib.comments is deprecated and will be removed before Django 1.8.',
        RemovedInDjango18Warning)
    warnings.filterwarnings(
        'ignore', 'Model class django.contrib.comments.models.* Django 1.9.',
        RemovedInDjango19Warning)
    # Load all the ALWAYS_INSTALLED_APPS.
    django.setup()

    # Load all the test model apps.
    test_modules = get_test_modules()

    # Reduce given test labels to just the app module path
    test_labels_set = set()
    for label in test_labels:
        bits = label.split('.')
        if bits[:2] == ['django', 'contrib']:
            bits = bits[:3]
        else:
            bits = bits[:1]
        test_labels_set.add('.'.join(bits))

    for modpath, module_name in test_modules:
        if modpath:
            module_label = '.'.join([modpath, module_name])
        else:
            module_label = module_name
        # if the module (or an ancestor) was named on the command line, or
        # no modules were named (i.e., run all), import
        # this module and add it to INSTALLED_APPS.
        if not test_labels:
            module_found_in_labels = True
        else:
            module_found_in_labels = any(
                # exact match or ancestor match
                module_label == label or module_label.startswith(label + '.')
                for label in test_labels_set)

        installed_app_names = set(get_installed())
        if module_found_in_labels and module_label not in installed_app_names:
            if verbosity >= 2:
                print("Importing application %s" % module_name)
            # HACK.
            settings.INSTALLED_APPS.append(module_label)
            app_config = AppConfig.create(module_label)
            apps.app_configs[app_config.label] = app_config
            app_config.import_models(apps.all_models[app_config.label])
            apps.clear_cache()

    return state
Example #37
0
def _ready(self):
    from . import signals
    return _APPCFG.ready(self)
Example #38
0
 def ready(self):
     AppConfig.ready(self)
     bot = GobbleBot()
     import_bot_handlers()
Example #39
0
 def ready(self):
     from documents.signals import document_consumer_declaration
     from .signals import ConsumerDeclaration
     document_consumer_declaration.connect(ConsumerDeclaration.handle)
     AppConfig.ready(self)
username_field = lambda: getattr(get_user_model(), 'USERNAME_FIELD', 'username')

try:
    from django.contrib.auth import get_user_model
except ImportError:
    from django.contrib.auth.models import User
    get_user_model = lambda: User

try:
    from django.utils.encoding import smart_text
except ImportError:
    from django.utils.encoding import smart_unicode as smart_text

try:
    from django.contrib.contenttypes import fields as generic
except ImportError:
    from django.contrib.contenttypes import generic

try:
    from django.apps import AppConfig
    user_model_class = lambda: AppConfig.get_model(*user_model_label.split('.'))
except ImportError:
    from django.db import models
    user_model_class = lambda: models.get_model(*user_model_label.split('.'))

    class AppConfig(object):
        name = None

        def get_model(self, model_name):
            return models.get_model(self.name.split('.')[-1], model_name, only_installed=False)
Example #41
0
 def test_repr(self):
     ac = AppConfig('label', Stub(__path__=['a']))
     self.assertEqual(repr(ac), '<AppConfig: label>')
Example #42
0
 def _strip(self, entry):
     app_config = AppConfig.create(entry)
     return app_config.label
Example #43
0
    def test_dunder_path(self):
        """If single element in __path__, use it (in preference to __file__)."""
        ac = AppConfig('label', Stub(__path__=['a'], __file__='b/__init__.py'))

        self.assertEqual(ac.path, 'a')
Example #44
0
    def test_no_dunder_path_fallback_to_dunder_file(self):
        """If there is no __path__ attr, use __file__."""
        ac = AppConfig('label', Stub(__file__='b/__init__.py'))

        self.assertEqual(ac.path, 'b')
Example #45
0
 def _create_app_config(self, app_module):
     from django.apps import apps, AppConfig
     from django.conf import settings
     app = AppConfig(app_module.__name__, app_module)
     apps.populate(list(settings.INSTALLED_APPS) + [app])
     return app