Example #1
0
 def test_evaluated_lazysettings_repr(self):
     lazy_settings = LazySettings()
     module = os.environ.get(ENVIRONMENT_VARIABLE)
     expected = '<LazySettings "%s">' % module
     # Force evaluation of the lazy object.
     lazy_settings.APPEND_SLASH
     self.assertEqual(repr(lazy_settings), expected)
Example #2
0
def reg(request):
    """
    This fixture initializes an awx settings registry object and passes it as
    an argument into the test function.
    """
    cache = LocMemCache(str(uuid4()), {})  # make a new random cache each time
    settings = LazySettings()
    registry = SettingsRegistry(settings)

    # @pytest.mark.defined_in_file can be used to mark specific setting values
    # as "defined in a settings file".  This is analogous to manually
    # specifying a setting on the filesystem (e.g., in a local_settings.py in
    # development, or in /etc/tower/conf.d/<something>.py)
    defaults = request.node.get_marker('defined_in_file')
    if defaults:
        settings.configure(**defaults.kwargs)
    settings._wrapped = SettingsWrapper(settings._wrapped, cache, registry)
    return registry
Example #3
0
def test_https_logging_handler_connectivity_test(http_adapter, status, reason,
                                                 exc):
    http_adapter.status = status
    http_adapter.reason = reason
    settings = LazySettings()
    settings.configure(
        **{
            'LOG_AGGREGATOR_HOST':
            'example.org',
            'LOG_AGGREGATOR_PORT':
            8080,
            'LOG_AGGREGATOR_TYPE':
            'logstash',
            'LOG_AGGREGATOR_USERNAME':
            '******',
            'LOG_AGGREGATOR_PASSWORD':
            '******',
            'LOG_AGGREGATOR_LOGGERS':
            ['awx', 'activity_stream', 'job_events', 'system_tracking'],
            'CLUSTER_HOST_ID':
            '',
            'LOG_AGGREGATOR_TOWER_UUID':
            str(uuid4()),
            'LOG_AGGREGATOR_LEVEL':
            'DEBUG',
        })

    class FakeHTTPSHandler(HTTPSHandler):
        def __init__(self, *args, **kwargs):
            super(FakeHTTPSHandler, self).__init__(*args, **kwargs)
            self.session.mount('http://', http_adapter)

        def emit(self, record):
            return super(FakeHTTPSHandler, self).emit(record)

    with mock.patch.object(AWXProxyHandler,
                           'get_handler_class') as mock_get_class:
        mock_get_class.return_value = FakeHTTPSHandler
        if exc:
            with pytest.raises(exc) as e:
                AWXProxyHandler().perform_test(settings)
            assert str(e).endswith('%s: %s' % (status, reason))
        else:
            assert AWXProxyHandler().perform_test(settings) is None
Example #4
0
def settings(request):
    """Adds django settings dict to context"""

    dict_settings = dict()
    settings = LazySettings()
    #Good hack to use pdb-friendly dir function
    for k in dir(settings):
        #Wrap settings as object
        attr = getattr(settings._wrapped, k)
        if not callable(attr) and k.isupper() and not k.startswith('_'):
            dict_settings[k] = attr
    return dict_settings
Example #5
0
    def test_dict_setting_clear_defaults(self):
        """
        Test the ability to deactivate the merge feature of dictionary settings.
        """
        s = LazySettings()
        s.configure(CACHES={
            '_clear_defaults': True,
            'temp': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}
        })
        self.assertDictEqual(s.CACHES, {
            '_clear_defaults': True,
            'temp': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}
        })

        # Also work on a subkey
        s = LazySettings()
        s.configure(CACHES={
            'default': {
                '_clear_defaults': True,
                'LOCATION': 'unique-snowflake',
            }
        })
        self.assertDictEqual(s.CACHES, {
            'default': {
                '_clear_defaults': True,
                'LOCATION': 'unique-snowflake',
            }
        })
Example #6
0
    def test_dict_setting(self):
        """
        Test that dictionary-type settings can be "complemented", that is existing
        setting keys/values are not overriden by user settings, but merged into the
        existing dict.
        """
        s = LazySettings()  # Start with fresh settings from global_settings.py
        # Simply overwriting the key
        s.configure(CACHES={'default': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}})
        self.assertEqual(s.CACHES['default']['BACKEND'],
                         'django.core.cache.backends.dummy.DummyCache')

        s = LazySettings()
        # More complex overwriting
        s.configure(CACHES={
            'default': {'LOCATION': 'unique-snowflake'},
            'temp': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}
        })
        self.assertDictEqual(s.CACHES, {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake'
            },
            'temp': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
            }
        })
Example #7
0
def settings(request):
    """
    This fixture initializes a Django settings object that wraps our
    `awx.conf.settings.SettingsWrapper` and passes it as an argument into the
    test function.

    This mimics the work done by `awx.conf.settings.SettingsWrapper.initialize`
    on `django.conf.settings`.
    """
    cache = LocMemCache(str(uuid4()), {})  # make a new random cache each time
    settings = LazySettings()
    registry = SettingsRegistry(settings)

    # @pytest.mark.defined_in_file can be used to mark specific setting values
    # as "defined in a settings file".  This is analogous to manually
    # specifying a setting on the filesystem (e.g., in a local_settings.py in
    # development, or in /etc/tower/conf.d/<something>.py)
    in_file_marker = request.node.get_marker('defined_in_file')
    defaults = in_file_marker.kwargs if in_file_marker else {}
    defaults['DEFAULTS_SNAPSHOT'] = {}
    settings.configure(**defaults)
    settings._wrapped = SettingsWrapper(settings._wrapped, cache, registry)
    return settings
Example #8
0
 def test_configure_initializes_logging(self):
     settings = LazySettings()
     settings.configure(LOGGING_CONFIG='logging_tests.tests.dictConfig')
     self.assertTrue(dictConfig.called)
Example #9
0
    def test_configure(self):
        s = LazySettings()
        s.configure(SECRET_KEY='foo')

        self.assertTrue(s.is_overridden('SECRET_KEY'))
Example #10
0
 def test_configure_initializes_logging(self):
     settings = LazySettings()
     settings.configure(
         LOGGING_CONFIG='regressiontests.logging_tests.tests.dictConfig')
     self.assertTrue(dictConfig.called)
Example #11
0
 def test_nonupper_settings_prohibited_in_configure(self):
     s = LazySettings()
     with self.assertRaisesMessage(TypeError,
                                   "Setting 'foo' must be uppercase."):
         s.configure(foo='bar')
Example #12
0
 def test_nonupper_settings_ignored_in_default_settings(self):
     s = LazySettings()
     s.configure(SimpleNamespace(foo='bar'))
     with self.assertRaises(AttributeError):
         getattr(s, 'foo')
 def test_usersettingsholder_repr(self):
     lazy_settings = LazySettings()
     lazy_settings.configure(APPEND_SLASH=False)
     expected = '<UserSettingsHolder>'
     self.assertEqual(repr(lazy_settings._wrapped), expected)
Example #14
0
# -*- coding: utf-8 -*-

DJANGO_REQUEST_ENABLE_SETTING = 'DJANGO_REQUEST_ENABLE'
DJANGO_REQUEST_LOGFILE_SETTING = 'DJANGO_REQUEST_LOGFILE'
REQUEST_ID_HEADER_SETTING = 'DJANGO_REQUEST_LOG_REQUEST_ID_HEADER'
REQUEST_ID_RESPONSE_HEADER_SETTING = 'DJANGO_REQUEST_SET_REQUEST_ID_HEADER'
NO_REQUEST_ID = '-'

from django.conf import settings, LazySettings
from django_request_logger.log import LOGGING
import threading

__version__ = "0.1"

# ThreadLocal - dirty but does the job
local = threading.local()

if getattr(settings, DJANGO_REQUEST_ENABLE_SETTING, True):
    # override any existing logging configuration
    settings.LOGGING = LOGGING

    # create a new Settings object and pass in our settings,
    # we don't need/use the new Settings object, it is just to
    # get the private _configure_logging() method called
    unused_settings = LazySettings()
    unused_settings.configure(default_settings=settings)
Example #15
0
 def _show_toolbar(self, request):
     return bool(LazySettings().DEBUG)
Example #16
0
def handle_django_settings(filename):
    '''Attempts to load a Django project and get package dependencies from
    settings.

    Tested using Django 1.4 and 1.8. Not sure if some nuances are missed in
    the other versions.
    '''
    old_sys_path = sys.path[:]
    dirpath = os.path.dirname(filename)
    project = os.path.basename(dirpath)
    cwd = os.getcwd()
    project_path = os.path.normpath(os.path.join(dirpath, '..'))
    if project_path not in sys.path:
        sys.path.insert(0, project_path)
    os.chdir(project_path)

    project_settings = '{}.settings'.format(project)
    os.environ['DJANGO_SETTINGS_MODULE'] = project_settings

    try:
        import django
        # Sanity
        django.setup = lambda: False
    except ImportError:
        log.error('Found Django settings, but Django is not installed.')
        return

    log.warn('Loading Django Settings (Using {}): {}'
                    .format(django.get_version(), filename))

    from django.conf import LazySettings

    installed_apps = set()
    settings_imports = set()

    try:
        settings = LazySettings()
        settings._setup()
        for k, v in vars(settings._wrapped).items():
            if k not in _excluded_settings and re.match(r'^[A-Z_]+$', k):
                # log.debug('Scanning Django setting: %s', k)
                scan_django_settings(v, settings_imports)

        # Manually scan INSTALLED_APPS since the broad scan won't include
        # strings without a period in it .
        for app in getattr(settings, 'INSTALLED_APPS', []):
            if hasattr(app, '__file__') and getattr(app, '__file__'):
                imp, _ = utils.import_path_from_file(getattr(app, '__file__'))
                installed_apps.add(imp)
            else:
                installed_apps.add(app)
    except Exception as e:
        log.error('Could not load Django settings: %s', e)
        log.debug('', exc_info=True)
        return

    if not installed_apps or not settings_imports:
        log.error('Got empty settings values from Django settings.')

    try:
        from django.apps.registry import apps, Apps, AppRegistryNotReady
        # Django doesn't like it when the initial instance of `apps` is reused,
        # but it has to be populated before other instances can be created.
        if not apps.apps_ready:
            apps.populate(installed_apps)
        else:
            apps = Apps(installed_apps)

        start = time.time()
        while True:
            try:
                for app in apps.get_app_configs():
                    installed_apps.add(app.name)
            except AppRegistryNotReady:
                if time.time() - start > 10:
                    raise Exception('Bail out of waiting for Django')
                log.debug('Waiting for apps to load...')
                continue
            break
    except Exception as e:
        log.debug('Could not use AppConfig: {}'.format(e))

    # Restore before sub scans can occur
    sys.path[:] = old_sys_path
    os.chdir(cwd)

    for item in settings_imports:
        need_scan = item.startswith(_filescan_modules)
        yield ('django', item, project_path if need_scan else None)

    for app in installed_apps:
        need_scan = app.startswith(project)
        yield ('django', app, project_path if need_scan else None)
Example #17
0
 def test_usersettingsholder_repr(self):
     lazy_settings = LazySettings()
     lazy_settings.configure(APPEND_SLASH=False)
     expected = '<UserSettingsHolder>'
     self.assertEqual(repr(lazy_settings._wrapped), expected)
Example #18
0
    def test_configure(self):
        s = LazySettings()
        s.configure(SECRET_KEY="foo")

        self.assertTrue(s.is_overridden("SECRET_KEY"))
Example #19
0
    def test_configure(self):
        s = LazySettings()
        s.configure(SECRET_KEY='foo')

        self.assertTrue(s.is_overridden('SECRET_KEY'))
Example #20
0
 def test_nonupper_settings_ignored_in_default_settings(self):
     s = LazySettings()
     s.configure(SimpleNamespace(foo='bar'))
     with self.assertRaises(AttributeError):
         getattr(s, 'foo')
Example #21
0
 def test_nonupper_settings_prohibited_in_configure(self):
     s = LazySettings()
     with self.assertRaisesMessage(TypeError, "Setting 'foo' must be uppercase."):
         s.configure(foo='bar')
Example #22
0
def handle_django_settings(filename):
    '''Attempts to load a Django project and get package dependencies from
    settings.

    Tested using Django 1.4 and 1.8. Not sure if some nuances are missed in
    the other versions.
    '''
    old_sys_path = sys.path[:]
    dirpath = os.path.dirname(filename)
    project = os.path.basename(dirpath)
    cwd = os.getcwd()
    project_path = os.path.normpath(os.path.join(dirpath, '..'))
    if project_path not in sys.path:
        sys.path.insert(0, project_path)
    os.chdir(project_path)

    project_settings = '{}.settings'.format(project)
    os.environ['DJANGO_SETTINGS_MODULE'] = project_settings

    try:
        import django
        # Sanity
        django.setup = lambda: False
    except ImportError:
        log.error('Found Django settings, but Django is not installed.')
        return

    log.warn('Loading Django Settings (Using {}): {}'.format(
        django.get_version(), filename))

    from django.conf import LazySettings

    installed_apps = set()
    settings_imports = set()

    try:
        settings = LazySettings()
        settings._setup()
        for k, v in vars(settings._wrapped).items():
            if k not in _excluded_settings and re.match(r'^[A-Z_]+$', k):
                # log.debug('Scanning Django setting: %s', k)
                scan_django_settings(v, settings_imports)

        # Manually scan INSTALLED_APPS since the broad scan won't include
        # strings without a period in it .
        for app in getattr(settings, 'INSTALLED_APPS', []):
            if hasattr(app, '__file__') and getattr(app, '__file__'):
                imp, _ = utils.import_path_from_file(getattr(app, '__file__'))
                installed_apps.add(imp)
            else:
                installed_apps.add(app)
    except Exception as e:
        log.error('Could not load Django settings: %s', e)
        log.debug('', exc_info=True)
        return

    if not installed_apps or not settings_imports:
        log.error('Got empty settings values from Django settings.')

    try:
        from django.apps.registry import apps, Apps, AppRegistryNotReady
        # Django doesn't like it when the initial instance of `apps` is reused,
        # but it has to be populated before other instances can be created.
        if not apps.apps_ready:
            apps.populate(installed_apps)
        else:
            apps = Apps(installed_apps)

        start = time.time()
        while True:
            try:
                for app in apps.get_app_configs():
                    installed_apps.add(app.name)
            except AppRegistryNotReady:
                if time.time() - start > 10:
                    raise Exception('Bail out of waiting for Django')
                log.debug('Waiting for apps to load...')
                continue
            break
    except Exception as e:
        log.debug('Could not use AppConfig: {}'.format(e))

    # Restore before sub scans can occur
    sys.path[:] = old_sys_path
    os.chdir(cwd)

    for item in settings_imports:
        need_scan = item.startswith(_filescan_modules)
        yield ('django', item, project_path if need_scan else None)

    for app in installed_apps:
        need_scan = app.startswith(project)
        yield ('django', app, project_path if need_scan else None)
Example #23
0
    def test_configure(self):
        s = LazySettings()
        s.configure(SECRET_KEY="foo")

        self.assertTrue(s.is_overridden("SECRET_KEY"))
Example #24
0
 def test_unevaluated_lazysettings_repr(self):
     lazy_settings = LazySettings()
     expected = '<LazySettings [Unevaluated]>'
     self.assertEqual(repr(lazy_settings), expected)
Example #25
0
 def __reset_settings():
     os.environ['DJANGO_SETTINGS_MODULE'] = _DJANGO_SETTINGS_MODULE
     conf.settings = LazySettings()
Example #26
0
import jwt, re, logging
import traceback
from channels.auth import AuthMiddlewareStack
from django.contrib.auth.models import AnonymousUser
from django.conf import LazySettings
from jwt import InvalidSignatureError, ExpiredSignatureError, DecodeError
from urllib import parse
from rbac.models import UserProfile
from django.db import close_old_connections

warn_logger = logging.getLogger('warn')
settings = LazySettings()


class TokenAuthMiddleware:
    def __init__(self, inner):
        self.inner = inner

    def __call__(self, scope):
        # Close old database connections to prevent usage of timed out connections
        close_old_connections()
        query = parse.parse_qs(scope['query_string'].decode("utf-8"))
        try:
            query = parse.parse_qs(
                scope['query_string'].decode("utf-8"))['token'][0]
            if query:
                try:
                    user_jwt = jwt.decode(
                        query,
                        settings.SECRET_KEY,
                    )
Example #27
0
def test_base_logging_handler_from_django_settings(param,
                                                   django_settings_name):
    settings = LazySettings()
    settings.configure(**{django_settings_name: 'EXAMPLE'})
    handler = BaseHandler.from_django_settings(settings)
    assert hasattr(handler, param) and getattr(handler, param) == 'EXAMPLE'