def test_url_args(self):
url = "locmem://?timeout=5"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "")
self.assertEqual(config["TIMEOUT"], "5")
def test_url_with_name_args(self):
url = "locmem://unique-snowflakes?timeout=5"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unique-snowflakes")
self.assertEqual(config["TIMEOUT"], "5")
def test_memcached_url_returns_pylibmc_cache():
url = 'memcached://127.0.0.1:11211?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django.core.cache.backends.memcached.PyLibMCCache'
assert config['LOCATION'] == '127.0.0.1:11211'
assert config['KEY_PREFIX'] == 'site1'
def test_query_string_params_are_converted_to_cache_options():
url = 'db://my_cache_table?max_entries=1000&cull_frequency=2'
config = django_cache_url.parse(url)
assert 'OPTIONS' in config
assert config['OPTIONS']['MAX_ENTRIES'] == 1000
assert config['OPTIONS']['CULL_FREQUENCY'] == 2
def test_url_multiple_hosts(self):
url = "memcached://127.0.0.1:11211,192.168.0.100:11211?key_prefix=site1"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "127.0.0.1:11211;192.168.0.100:11211")
self.assertEqual(config.get("KEY_PREFIX"), "site1")
def test_url(self):
url = "memcached://127.0.0.1:11211"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "127.0.0.1:11211")
self.assertEqual(config.get("KEY_PREFIX"), None)
def test_redis_with_password():
url = 'redis://:[email protected]:6379/0'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'redis://127.0.0.1:6379/0'
assert config['OPTIONS']['PASSWORD'] == 'redispass'
def test_hiredis():
url = 'hiredis://127.0.0.1:6379/0?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'redis://127.0.0.1:6379/0'
assert config['OPTIONS']['PARSER_CLASS'] == 'redis.connection.HiredisParser'
def test_hiredis_socket():
url = 'hiredis:///path/to/socket/1?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'unix:/path/to/socket:1'
assert config['OPTIONS']['PARSER_CLASS'] == 'redis.connection.HiredisParser'
def test_redis_socket():
url = 'redis:///path/to/socket/1?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'unix:/path/to/socket:1'
assert 'OPTIONS' not in config
def test_socket(self):
url = "memcached:///path/to/socket"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unix:/path/to/socket")
self.assertEqual(config.get("KEY_PREFIX"), None)
def test_socket_args(self):
url = "memcached:///path/to/socket?key_prefix=site1"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unix:/path/to/socket")
self.assertEqual(config["KEY_PREFIX"], "site1")
def test_url_password(self):
url = "redis://*****:*****@localhost:6379/"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "localhost:6379:0")
self.assertEqual(config["OPTIONS"]["PASSWORD"], "pass")
def test_url_args(self):
url = "file:///path/to/file?timeout=5"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "/path/to/file")
self.assertEqual(config["TIMEOUT"], "5")
def test_url_args(self):
url = "dummy://?key_prefix=site1"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "")
self.assertEqual(config["KEY_PREFIX"], "site1")
def test_bmemcached_with_user_and_password():
url = 'bmemcached://*****:*****@127.0.0.1:6379'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_bmemcached.memcached.BMemcached'
assert config['LOCATION'] == '127.0.0.1:6379'
assert config['OPTIONS']['username'] == 'user'
assert config['OPTIONS']['password'] == 'pass'
def test_url_args(self):
url = "redis://*****:*****@localhost:6379:1/?key_prefix=site1"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "localhost:6379:1")
self.assertEqual(config["OPTIONS"]["PASSWORD"], "pass")
self.assertEqual(config["KEY_PREFIX"], "site1")
def test_url(self):
url = "hiredis://localhost:6379/"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "localhost:6379:0")
self.assertEqual(config.get("KEY_PREFIX"), None)
self.assertEqual(config["OPTIONS"]["PARSER_CLASS"], "redis.connection.HiredisParser")
def test_socket_args(self):
url = "redis:///path/to/socket:1?key_prefix=site1"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unix:/path/to/socket:1")
self.assertEqual(config.get("OPTIONS"), None)
self.assertEqual(config["KEY_PREFIX"], "site1")
def test_url(self):
url = "redis://localhost:6379"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "localhost:6379:0")
self.assertEqual(config.get("OPTIONS"), None)
self.assertEqual(config.get("KEY_PREFIX"), None)
def test_bmemcached_with_user_only():
url = 'bmemcached://[email protected]:6379'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_bmemcached.memcached.BMemcached'
assert config['LOCATION'] == '127.0.0.1:6379'
assert config['OPTIONS']['username'] == 'user'
assert 'password' not in config['OPTIONS'].keys()
def test_socket(self):
url = "hiredis:///path/to/socket"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unix:/path/to/socket:0")
self.assertEqual(config.get("KEY_PREFIX"), None)
self.assertEqual(config["OPTIONS"]["PARSER_CLASS"], "redis.connection.HiredisParser")
def test_uwsgicache_url_returns_uwsgicache_cache():
url = 'uwsgicache://cachename/'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'uwsgicache.UWSGICache'
assert config['LOCATION'] == 'cachename'
# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
SITE_ID = 1
# Caching
try:
import django_cache_url
CACHES = {'default': django_cache_url.parse(get_env('DJANGO_CACHE_URL'))}
CACHES['default']['TIMEOUT'] = None
except (ImportError, TypeError):
pass
# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/
LANGUAGE_CODE = 'de'
TIME_ZONE = 'Europe/Berlin'
USE_I18N = True
USE_L10N = True
AXES_COOLOFF_TIME = 1 # 1 hour cooloff time
AXES_FAILURE_LIMIT = 100
# Disable Caching in development
if DEBUG:
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.dummy.DummyCache",
}
}
else:
CACHES = {
"default": django_cache_url.parse(os.getenv("MEMCACHED_URL"))
} # set by dokku automatically when linking apps
# # Sentry Monitoring Configuration ========================================================
# only in production
if not DEBUG:
sentry_sdk.init(
dsn=os.getenv("SENTRY_KEY"),
integrations=[DjangoIntegration()],
traces_sample_rate=0.3,
# If you wish to associate users to errors (assuming you are using
# django.contrib.auth) you may enable sending PII data.
send_default_pii=True,
)
ALLOWED_HOSTS = []
'django_password_protect.PasswordProtectMiddleware',
'django.middleware.cache.UpdateCacheMiddleware',
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'debug_toolbar.middleware.DebugToolbarMiddleware',
'django.middleware.cache.FetchFromCacheMiddleware',
'django.contrib.redirects.middleware.RedirectFallbackMiddleware',
'django.contrib.admindocs.middleware.XViewMiddleware',
'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware',
'django.contrib.messages.middleware.MessageMiddleware'
]
CACHES = {
'default':
django_cache_url.parse(os.environ.get('CACHE_URL', 'dummy://')),
'filecache':
django_cache_url.parse(
os.environ.get('FILE_CACHE_URL', 'file:///tmp/filecache'))
}
AUTHENTICATION_BACKENDS = (
'django_membersuite_auth.backends.MemberSuiteBackend', )
if 'test' in sys.argv:
AUTHENTICATION_BACKENDS = (
'django.contrib.auth.backends.ModelBackend',
'django_membersuite_auth.backends.MemberSuiteBackend')
AUTH_USER_MODEL = 'auth.User'
LOGIN_URL = '/accounts/login/'
def test_memcached_socket_url():
url = 'memcached:///path/to/socket/'
config = django_cache_url.parse(url)
assert config['LOCATION'] == 'unix:/path/to/socket/'
def test_dummy_url_returns_dummy_cache():
config = django_cache_url.parse('dummy://')
assert config['BACKEND'] == 'django.core.cache.backends.dummy.DummyCache'
def test_query_string_params_are_converted_to_cache_arguments():
url = 'redis:///path/to/socket?key_prefix=foo&bar=herp'
config = django_cache_url.parse(url)
assert config['KEY_PREFIX'] == 'foo'
assert config['BAR'] == 'herp'
WSGI_APPLICATION = 'comiccollector.wsgi.application'
DATABASES = {
'default':
dj_database_url.config(
default=os.environ.get(
'DB_URL',
'postgres://*****:*****@localhost:5432/comiccollector'
),
conn_max_age=None,
)
}
CACHES = {
'default':
django_cache_url.parse(
os.environ.get('CACHE_URL', 'hiredis://localhost:6379'))
}
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.CommonPasswordValidator',
},
from django.conf import settings
from django.core.urlresolvers import reverse
from django.test import TestCase, override_settings
import django_cache_url
from mock import patch
from time import sleep
import sys
# @override_settings(BROWSE_RATE_LIMIT='10/5m') # couldn't get this to work
@override_settings(
CACHES={'default': django_cache_url.parse('locmem://hub_test')},
RATELIMIT_ENABLE=True)
class RateLimitTestCase(TestCase):
"""
Test rate limiting for specific urls
"""
def setUp(self):
pass
def test_login(self):
"""
5th request in succession should raise Ratelimited
"""
url = reverse('login')
error_count = 0
for i in range(6):
response = self.client.post(url, {'username': '******'})
if i <= 4:
def test_locmem_url_returns_locmem_cache():
config = django_cache_url.parse('locmem://')
assert config['BACKEND'] == 'django.core.cache.backends.locmem.LocMemCache'
def test_dummy_url_returns_dummy_cache():
config = django_cache_url.parse('dummy://')
assert config['BACKEND'] == 'django.core.cache.backends.dummy.DummyCache'
def test_dj_cache_url(self, env, set_env):
cache_url = "redis://redis:6379/0"
set_env({"CACHE_URL": cache_url})
res = env.dj_cache_url("CACHE_URL")
assert res == django_cache_url.parse(cache_url)
def test_uwsgicache_default_location():
url = 'uwsgicache://'
config = django_cache_url.parse(url)
assert config['LOCATION'] == 'default'
def test_file_url_returns_file_cache_backend_absolute():
config = django_cache_url.parse('file:////var/herp')
assert config['BACKEND'] == 'django.core.cache.backends.filebased.FileBasedCache'
assert config['LOCATION'] == '/var/herp'
def test_locmem_url_returns_locmem_cache():
config = django_cache_url.parse('locmem://')
assert config['BACKEND'] == 'django.core.cache.backends.locmem.LocMemCache'
def to_settings(self, data, settings):
import django_cache_url
import dj_database_url
import warnings
from functools import partial
from aldryn_addons.utils import boolean_ish, djsenv
env = partial(djsenv, settings=settings)
# BASE_DIR should already be set by aldryn-addons
settings["BASE_DIR"] = env("BASE_DIR", required=True)
settings["DATA_ROOT"] = env(
"DATA_ROOT", os.path.join(settings["BASE_DIR"], "data")
)
settings["SECRET_KEY"] = env("SECRET_KEY", "this-is-not-very-random")
settings["DEBUG"] = boolean_ish(env("DEBUG", False))
settings["ENABLE_SYNCING"] = boolean_ish(
env("ENABLE_SYNCING", settings["DEBUG"])
)
settings["DISABLE_TEMPLATE_CACHE"] = boolean_ish(
env("DISABLE_TEMPLATE_CACHE", settings["DEBUG"])
)
settings["DATABASE_URL"] = env("DATABASE_URL")
settings["CACHE_URL"] = env("CACHE_URL")
if env("DJANGO_MODE") == "build":
# In build mode we don't have any connected services like db or
# cache available. So we need to configure those things in a way
# they can run without real backends.
settings["DATABASE_URL"] = "sqlite://:memory:"
settings["CACHE_URL"] = "locmem://"
if not settings["DATABASE_URL"]:
settings["DATABASE_URL"] = "sqlite:///{}".format(
os.path.join(settings["DATA_ROOT"], "db.sqlite3")
)
warnings.warn(
"no database configured. Falling back to DATABASE_URL={0}".format(
settings["DATABASE_URL"]
),
RuntimeWarning,
)
settings["DATABASES"]["default"] = dj_database_url.parse(
settings["DATABASE_URL"]
)
if not settings["CACHE_URL"]:
settings["CACHE_URL"] = "locmem://"
warnings.warn(
"no cache configured. Falling back to CACHE_URL={0}".format(
settings["CACHE_URL"]
),
RuntimeWarning,
)
settings["CACHES"]["default"] = django_cache_url.parse(
settings["CACHE_URL"]
)
settings["ROOT_URLCONF"] = env("ROOT_URLCONF", "urls")
settings["ADDON_URLS_I18N"].append("aldryn_django.i18n_urls")
settings["WSGI_APPLICATION"] = "wsgi.application"
settings["INSTALLED_APPS"].extend(
[
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.sites",
"django.contrib.messages",
"django.contrib.admin",
"django.contrib.staticfiles",
"aldryn_django",
]
)
if settings["ENABLE_SYNCING"] or settings["DISABLE_TEMPLATE_CACHE"]:
loader_list_class = list
else:
loader_list_class = CachedLoader
settings["TEMPLATES"] = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": env(
"TEMPLATE_DIRS",
[os.path.join(settings["BASE_DIR"], "templates")],
),
"OPTIONS": {
"debug": boolean_ish(
env("TEMPLATE_DEBUG", settings["DEBUG"])
),
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
"django.template.context_processors.i18n",
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.template.context_processors.media",
"django.template.context_processors.csrf",
"django.template.context_processors.tz",
"django.template.context_processors.static",
"aldryn_django.context_processors.debug",
],
"loaders": loader_list_class(
[
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
"django.template.loaders.eggs.Loader",
]
),
},
}
]
settings["MIDDLEWARE_CLASSES"] = [
"django.contrib.sessions.middleware.SessionMiddleware",
# 'django.middleware.common.CommonMiddleware',
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
# 'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.locale.LocaleMiddleware",
"django.contrib.sites.middleware.CurrentSiteMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
# 'django.middleware.security.SecurityMiddleware',
]
if not env("DISABLE_GZIP"):
settings["MIDDLEWARE_CLASSES"].insert(
0, "django.middleware.gzip.GZipMiddleware"
)
settings["SITE_ID"] = env("SITE_ID", 1)
settings["ADDON_URLS_I18N_LAST"] = "aldryn_django.urls_redirect"
self.domain_settings(data, settings, env=env)
self.security_settings(data, settings, env=env)
self.server_settings(settings, env=env)
self.logging_settings(settings, env=env)
# Order matters, sentry settings rely on logging being configured.
self.sentry_settings(settings, env=env)
self.storage_settings_for_media(settings, env=env)
self.storage_settings_for_static(data, settings, env=env)
self.email_settings(data, settings, env=env)
self.i18n_settings(data, settings, env=env)
self.migration_settings(settings, env=env)
settings["ALDRYN_DJANGO_ENABLE_GIS"] = data["enable_gis"]
if settings["ALDRYN_DJANGO_ENABLE_GIS"]:
self.gis_settings(settings, env=env)
return settings
def test_file_url_returns_file_cache_backend_relative():
config = django_cache_url.parse('file:///herp/bar')
assert config['BACKEND'] == 'django.core.cache.backends.filebased.FileBasedCache'
assert config['LOCATION'] == 'herp/bar'
def test_redis():
url = 'redis://127.0.0.1:6379/0?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'redis://127.0.0.1:6379/0'
def test_memcached_url_multiple_locations():
url = 'memcached://127.0.0.1:11211,192.168.0.100:11211?key_prefix=site1'
config = django_cache_url.parse(url)
assert config['LOCATION'] == '127.0.0.1:11211;192.168.0.100:11211'
def test_url_with_name(self):
url = "locmem://unique-snowflakes"
config = django_cache_url.parse(url)
self.assertEqual(config["BACKEND"], self.backend)
self.assertEqual(config["LOCATION"], "unique-snowflakes")
def test_db_url_returns_database_cache_backend():
url = 'db://super_caching_table'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django.core.cache.backends.db.DatabaseCache'
assert config['LOCATION'] == 'super_caching_table'
def test_unknown_cache_backend():
with pytest.raises(Exception):
django_cache_url.parse('donkey://127.0.0.1/foo')
PROJECT_ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))
ROOT_URLCONF = 'saleor.urls'
WSGI_APPLICATION = 'saleor.wsgi.application'
ADMINS = (
# ('Your Name', '*****@*****.**'),
)
MANAGERS = ADMINS
INTERNAL_IPS = os.environ.get('INTERNAL_IPS', '127.0.0.1').split()
CACHE_URL = os.environ.get('CACHE_URL',
os.environ.get('REDIS_URL', 'locmem://'))
CACHES = {'default': django_cache_url.parse(CACHE_URL)}
SQLITE_DB_URL = 'sqlite:///' + os.path.join(PROJECT_ROOT, 'dev.sqlite')
DATABASES = {'default': dj_database_url.config(default=SQLITE_DB_URL)}
TIME_ZONE = 'America/Chicago'
LANGUAGE_CODE = 'en-us'
USE_I18N = True
USE_L10N = True
USE_TZ = True
EMAIL_URL = os.environ.get('EMAIL_URL', 'console://')
email_config = dj_email_url.parse(EMAIL_URL)
def to_settings(self, data, settings):
import django_cache_url
import dj_database_url
import warnings
from functools import partial
from aldryn_addons.utils import boolean_ish, djsenv
env = partial(djsenv, settings=settings)
# BASE_DIR should already be set by aldryn-addons
settings['BASE_DIR'] = env('BASE_DIR', required=True)
settings['DATA_ROOT'] = env('DATA_ROOT',
os.path.join(settings['BASE_DIR'], 'data'))
settings['SECRET_KEY'] = env('SECRET_KEY', 'this-is-not-very-random')
settings['DEBUG'] = boolean_ish(env('DEBUG', False))
settings['ENABLE_SYNCING'] = boolean_ish(
env('ENABLE_SYNCING', settings['DEBUG']))
settings['DISABLE_TEMPLATE_CACHE'] = boolean_ish(
env('DISABLE_TEMPLATE_CACHE', settings['DEBUG']))
settings['DATABASE_URL'] = env('DATABASE_URL')
settings['CACHE_URL'] = env('CACHE_URL')
if env('DJANGO_MODE') == 'build':
# In build mode we don't have any connected services like db or
# cache available. So we need to configure those things in a way
# they can run without real backends.
settings['DATABASE_URL'] = 'sqlite://:memory:'
settings['CACHE_URL'] = 'locmem://'
if not settings['DATABASE_URL']:
settings['DATABASE_URL'] = 'sqlite:///{}'.format(
os.path.join(settings['DATA_ROOT'], 'db.sqlite3'))
warnings.warn(
'no database configured. Falling back to DATABASE_URL={0}'.
format(settings['DATABASE_URL']),
RuntimeWarning,
)
settings['DATABASES']['default'] = dj_database_url.parse(
settings['DATABASE_URL'])
if not settings['CACHE_URL']:
settings['CACHE_URL'] = 'locmem://'
warnings.warn(
'no cache configured. Falling back to CACHE_URL={0}'.format(
settings['CACHE_URL']),
RuntimeWarning,
)
settings['CACHES']['default'] = django_cache_url.parse(
settings['CACHE_URL'])
settings['ROOT_URLCONF'] = env('ROOT_URLCONF', 'urls')
settings['ADDON_URLS_I18N'].append('aldryn_django.i18n_urls')
settings['WSGI_APPLICATION'] = 'wsgi.application'
settings['INSTALLED_APPS'].extend([
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.admin',
'django.contrib.staticfiles',
'aldryn_django',
])
if settings['ENABLE_SYNCING'] or settings['DISABLE_TEMPLATE_CACHE']:
loader_list_class = list
else:
loader_list_class = CachedLoader
settings['TEMPLATES'] = [
{
'BACKEND':
'django.template.backends.django.DjangoTemplates',
'DIRS':
env(
'TEMPLATE_DIRS',
[os.path.join(settings['BASE_DIR'], 'templates')],
),
'OPTIONS': {
'debug':
boolean_ish(env('TEMPLATE_DEBUG', settings['DEBUG'])),
'context_processors': [
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'django.template.context_processors.i18n',
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.template.context_processors.media',
'django.template.context_processors.csrf',
'django.template.context_processors.tz',
'django.template.context_processors.static',
'aldryn_django.context_processors.debug',
],
'loaders':
loader_list_class([
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
'django.template.loaders.eggs.Loader',
]),
},
},
]
settings['MIDDLEWARE_CLASSES'] = [
'django.contrib.sessions.middleware.SessionMiddleware',
# 'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
# 'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.locale.LocaleMiddleware',
'django.contrib.sites.middleware.CurrentSiteMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
# 'django.middleware.security.SecurityMiddleware',
]
if not env('DISABLE_GZIP'):
settings['MIDDLEWARE_CLASSES'].insert(
0, 'django.middleware.gzip.GZipMiddleware')
settings['SITE_ID'] = env('SITE_ID', 1)
settings['ADDON_URLS_I18N_LAST'] = 'aldryn_django.urls_redirect'
self.domain_settings(data, settings, env=env)
self.security_settings(data, settings, env=env)
self.server_settings(settings, env=env)
self.logging_settings(settings, env=env)
# Order matters, sentry settings rely on logging being configured.
self.sentry_settings(settings, env=env)
self.storage_settings_for_media(settings, env=env)
self.storage_settings_for_static(data, settings, env=env)
self.email_settings(data, settings, env=env)
self.i18n_settings(data, settings, env=env)
self.migration_settings(settings, env=env)
settings['ALDRYN_DJANGO_ENABLE_GIS'] = data['enable_gis']
if settings['ALDRYN_DJANGO_ENABLE_GIS']:
self.gis_settings(settings, env=env)
return settings
DEBUG = env('DJANGO_DEBUG', 'off') == 'on'
GEOS_LIBRARY_PATH = '/usr/local/lib/libgeos_c.so'
GDAL_LIBRARY_PATH = '/usr/local/lib/libgdal.so'
SECRET_KEY = env('SECRET_KEY', required=True)
DATABASE_URL = env('DATABASE_URL', required=True)
DATABASES = {'default': dj_database_url.parse(DATABASE_URL)}
DATABASES['default']['CONN_MAX_AGE'] = 60
DATABASES['default']['ATOMIC_REQUESTS'] = True
DATABASES['default']['ENGINE'] = 'django.contrib.gis.db.backends.postgis'
REDIS_URL = env('REDIS_URL', required=True)
BROKER_URL = env('BROKER_URL', REDIS_URL)
CELERY_RESULT_BACKEND = env('CELERY_RESULT_BACKEND', REDIS_URL)
CACHE_URL = env('CACHE_URL', REDIS_URL)
CACHES = {'default': django_cache_url.parse(CACHE_URL)}
if CACHES['default']['BACKEND'] == 'django_redis.cache.RedisCache':
if 'OPTIONS' not in CACHES['default']:
CACHES['default']['OPTIONS'] = {}
CACHES['default']['OPTIONS']['CLIENT_CLASS'] = 'django_redis.client.DefaultClient'
RAVEN_CONFIG = {
'dsn': env('RAVEN_DSN'),
'release': env('RAPIDPRO_VERSION'),
}
# -----------------------------------------------------------------------------------
# Used when creating callbacks for Twilio, Nexmo etc..
# -----------------------------------------------------------------------------------
HOSTNAME = env('DOMAIN_NAME', 'rapidpro.ngrok.com')
TEMBA_HOST = env('TEMBA_HOST', HOSTNAME)
def test_db_url_returns_database_cache_backend():
url = 'db://super_caching_table'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'django.core.cache.backends.db.DatabaseCache'
assert config['LOCATION'] == 'super_caching_table'
def test_basic_config_with_password():
url = f'redis://:[email protected]:6379/?lib={redis_cache}'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'redis_cache.RedisCache'
assert config['LOCATION'] == 'redis://:[email protected]:6379/0'
def test_file_url_returns_file_cache_backend():
config = django_cache_url.parse('file:///herp')
assert config['BACKEND'] == 'django.core.cache.backends.filebased.FileBasedCache'
assert config['LOCATION'] == '/herp'
def test_rediss_config():
url = f'rediss://127.0.0.1:6379/?lib={redis_cache}'
config = django_cache_url.parse(url)
assert config['BACKEND'] == 'redis_cache.RedisCache'
assert config['LOCATION'] == 'rediss://127.0.0.1:6379/0'
def test_query_string_params_are_converted_to_cache_arguments():
url = 'redis:///path/to/socket?key_prefix=foo&bar=herp'
config = django_cache_url.parse(url)
assert config['KEY_PREFIX'] == 'foo'
assert config['BAR'] == 'herp'
def cache_settings(self, settings, env):
import django_cache_url
cache_url = env('CACHE_URL')
if cache_url:
settings['CACHES']['default'] = django_cache_url.parse(cache_url)
def test_unknown_cache_backend():
with pytest.raises(Exception):
django_cache_url.parse('donkey://127.0.0.1/foo')
def cache_url(self, var="CACHE_URL", default=NOT_SET, **kwargs):
url = self._get_value(var, cast=text_type, default=default)
return dict(django_cache_url.parse(url), **kwargs)
