def test_bootstrap_options_no_config_only_sentry_options(settings):
"SENTRY_OPTIONS is only declared, but should be promoted into settings"
settings.SENTRY_OPTIONS = {
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.use-ssl": False,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
bootstrap_options(settings)
assert settings.SECRET_KEY == "my-system-secret-key"
assert settings.EMAIL_BACKEND == "my-mail-backend"
assert settings.EMAIL_HOST == "my-mail-host"
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == "my-mail-username"
assert settings.EMAIL_HOST_PASSWORD == "my-mail-password"
assert settings.EMAIL_USE_TLS is True
assert settings.EMAIL_USE_SSL is False
assert settings.SERVER_EMAIL == "my-mail-from"
assert settings.EMAIL_SUBJECT_PREFIX == "my-mail-subject-prefix"
def test_bootstrap_options_no_config(settings):
"No config file should gracefully extract values out of settings"
settings.SECRET_KEY = "my-system-secret-key"
settings.EMAIL_BACKEND = "my-mail-backend"
settings.EMAIL_HOST = "my-mail-host"
settings.EMAIL_PORT = 123
settings.EMAIL_HOST_USER = "******"
settings.EMAIL_HOST_PASSWORD = "******"
settings.EMAIL_USE_TLS = True
settings.SERVER_EMAIL = "my-mail-from"
settings.EMAIL_SUBJECT_PREFIX = "my-mail-subject-prefix"
settings.FOO_BAR = "lol"
bootstrap_options(settings)
assert settings.SENTRY_OPTIONS == {
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
def test_bootstrap_options_no_config(settings):
"No config file should gracefully extract values out of settings"
settings.SECRET_KEY = "my-system-secret-key"
settings.EMAIL_BACKEND = "my-mail-backend"
settings.EMAIL_HOST = "my-mail-host"
settings.EMAIL_PORT = 123
settings.EMAIL_HOST_USER = "******"
settings.EMAIL_HOST_PASSWORD = "******"
settings.EMAIL_USE_TLS = True
settings.SERVER_EMAIL = "my-mail-from"
settings.EMAIL_SUBJECT_PREFIX = "my-mail-subject-prefix"
settings.FOO_BAR = "lol"
bootstrap_options(settings)
assert settings.SENTRY_OPTIONS == {
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
def test_bootstrap_options_no_config(settings):
"No config file should gracefully extract values out of settings"
settings.SECRET_KEY = 'my-system-secret-key'
settings.EMAIL_BACKEND = 'my-mail-backend'
settings.EMAIL_HOST = 'my-mail-host'
settings.EMAIL_PORT = 123
settings.EMAIL_HOST_USER = '******'
settings.EMAIL_HOST_PASSWORD = '******'
settings.EMAIL_USE_TLS = True
settings.SERVER_EMAIL = 'my-mail-from'
settings.EMAIL_SUBJECT_PREFIX = 'my-mail-subject-prefix'
settings.FOO_BAR = 'lol'
bootstrap_options(settings)
assert settings.SENTRY_OPTIONS == {
'system.secret-key': 'my-system-secret-key',
'mail.backend': 'my-mail-backend',
'mail.host': 'my-mail-host',
'mail.port': 123,
'mail.username': '******',
'mail.password': '******',
'mail.use-tls': True,
'mail.from': 'my-mail-from',
'mail.subject-prefix': 'my-mail-subject-prefix',
}
def test_bootstrap_options_malformed_yml(settings, config_yml):
config_yml.write("1")
with pytest.raises(ConfigurationError):
bootstrap_options(settings, str(config_yml))
config_yml.write("{{{")
with pytest.raises(ConfigurationError):
bootstrap_options(settings, str(config_yml))
def test_bootstrap_options_malformed_yml(settings, config_yml):
config_yml.write("1")
with pytest.raises(ConfigurationError):
bootstrap_options(settings, str(config_yml))
config_yml.write("{{{")
with pytest.raises(ConfigurationError):
bootstrap_options(settings, str(config_yml))
def test_bootstrap_options_malformed_yml(settings, config_yml):
config_yml.write('1')
with pytest.raises(ConfigurationError):
bootstrap_options(settings, six.text_type(config_yml))
config_yml.write('{{{')
with pytest.raises(ConfigurationError):
bootstrap_options(settings, six.text_type(config_yml))
def test_bootstrap_options_simple(settings, config_yml):
"Config options are specified in both places, but config.yml should prevail"
settings.SECRET_KEY = "xxx"
settings.EMAIL_BACKEND = "xxx"
settings.EMAIL_HOST = "xxx"
settings.EMAIL_PORT = 6969
settings.EMAIL_HOST_USER = "******"
settings.EMAIL_HOST_PASSWORD = "******"
settings.EMAIL_USE_TLS = False
settings.EMAIL_USE_SSL = False
settings.SERVER_EMAIL = "xxx"
settings.EMAIL_SUBJECT_PREFIX = "xxx"
settings.SENTRY_OPTIONS = {"something.else": True}
config_yml.write(
"""\
foo.bar: my-foo-bar
system.secret-key: my-system-secret-key
mail.backend: my-mail-backend
mail.host: my-mail-host
mail.port: 123
mail.username: my-mail-username
mail.password: my-mail-password
mail.use-tls: true
mail.use-ssl: false
mail.from: my-mail-from
mail.subject-prefix: my-mail-subject-prefix
"""
)
bootstrap_options(settings, six.text_type(config_yml))
assert settings.SENTRY_OPTIONS == {
"something.else": True,
"foo.bar": "my-foo-bar",
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.use-ssl": False,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
assert settings.SECRET_KEY == "my-system-secret-key"
assert settings.EMAIL_BACKEND == "my-mail-backend"
assert settings.EMAIL_HOST == "my-mail-host"
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == "my-mail-username"
assert settings.EMAIL_HOST_PASSWORD == "my-mail-password"
assert settings.EMAIL_USE_TLS is True
assert settings.EMAIL_USE_SSL is False
assert settings.SERVER_EMAIL == "my-mail-from"
assert settings.EMAIL_SUBJECT_PREFIX == "my-mail-subject-prefix"
def test_bootstrap_options_simple(settings, config_yml):
"Config options are specified in both places, but config.yml should prevail"
settings.SECRET_KEY = "xxx"
settings.EMAIL_BACKEND = "xxx"
settings.EMAIL_HOST = "xxx"
settings.EMAIL_PORT = 6969
settings.EMAIL_HOST_USER = "******"
settings.EMAIL_HOST_PASSWORD = "******"
settings.EMAIL_USE_TLS = False
settings.SERVER_EMAIL = "xxx"
settings.EMAIL_SUBJECT_PREFIX = "xxx"
settings.SENTRY_OPTIONS = {"something.else": True}
config_yml.write(
"""\
foo.bar: my-foo-bar
system.secret-key: my-system-secret-key
mail.backend: my-mail-backend
mail.host: my-mail-host
mail.port: 123
mail.username: my-mail-username
mail.password: my-mail-password
mail.use-tls: true
mail.from: my-mail-from
mail.subject-prefix: my-mail-subject-prefix
"""
)
bootstrap_options(settings, str(config_yml))
assert settings.SENTRY_OPTIONS == {
"something.else": True,
"foo.bar": "my-foo-bar",
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
assert settings.SECRET_KEY == "my-system-secret-key"
assert settings.EMAIL_BACKEND == "my-mail-backend"
assert settings.EMAIL_HOST == "my-mail-host"
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == "my-mail-username"
assert settings.EMAIL_HOST_PASSWORD == "my-mail-password"
assert settings.EMAIL_USE_TLS is True
assert settings.SERVER_EMAIL == "my-mail-from"
assert settings.EMAIL_SUBJECT_PREFIX == "my-mail-subject-prefix"
def test_bootstrap_options_simple(settings, config_yml):
"Config options are specified in both places, but config.yml should prevail"
settings.SECRET_KEY = 'xxx'
settings.EMAIL_BACKEND = 'xxx'
settings.EMAIL_HOST = 'xxx'
settings.EMAIL_PORT = 6969
settings.EMAIL_HOST_USER = '******'
settings.EMAIL_HOST_PASSWORD = '******'
settings.EMAIL_USE_TLS = False
settings.SERVER_EMAIL = 'xxx'
settings.EMAIL_SUBJECT_PREFIX = 'xxx'
settings.SENTRY_OPTIONS = {'something.else': True}
config_yml.write(
"""\
foo.bar: my-foo-bar
system.secret-key: my-system-secret-key
mail.backend: my-mail-backend
mail.host: my-mail-host
mail.port: 123
mail.username: my-mail-username
mail.password: my-mail-password
mail.use-tls: true
mail.from: my-mail-from
mail.subject-prefix: my-mail-subject-prefix
"""
)
bootstrap_options(settings, six.text_type(config_yml))
assert settings.SENTRY_OPTIONS == {
'something.else': True,
'foo.bar': 'my-foo-bar',
'system.secret-key': 'my-system-secret-key',
'mail.backend': 'my-mail-backend',
'mail.host': 'my-mail-host',
'mail.port': 123,
'mail.username': '******',
'mail.password': '******',
'mail.use-tls': True,
'mail.from': 'my-mail-from',
'mail.subject-prefix': 'my-mail-subject-prefix',
}
assert settings.SECRET_KEY == 'my-system-secret-key'
assert settings.EMAIL_BACKEND == 'my-mail-backend'
assert settings.EMAIL_HOST == 'my-mail-host'
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == 'my-mail-username'
assert settings.EMAIL_HOST_PASSWORD == 'my-mail-password'
assert settings.EMAIL_USE_TLS is True
assert settings.SERVER_EMAIL == 'my-mail-from'
assert settings.EMAIL_SUBJECT_PREFIX == 'my-mail-subject-prefix'
def test_bootstrap_options_no_config_only_sentry_options(settings):
"SENTRY_OPTIONS is only declared, but should be promoted into settings"
settings.SENTRY_OPTIONS = {
"system.secret-key": "my-system-secret-key",
"mail.backend": "my-mail-backend",
"mail.host": "my-mail-host",
"mail.port": 123,
"mail.username": "******",
"mail.password": "******",
"mail.use-tls": True,
"mail.from": "my-mail-from",
"mail.subject-prefix": "my-mail-subject-prefix",
}
bootstrap_options(settings)
assert settings.SECRET_KEY == "my-system-secret-key"
assert settings.EMAIL_BACKEND == "my-mail-backend"
assert settings.EMAIL_HOST == "my-mail-host"
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == "my-mail-username"
assert settings.EMAIL_HOST_PASSWORD == "my-mail-password"
assert settings.EMAIL_USE_TLS is True
assert settings.SERVER_EMAIL == "my-mail-from"
assert settings.EMAIL_SUBJECT_PREFIX == "my-mail-subject-prefix"
def test_bootstrap_options_no_config_only_sentry_options(settings):
"SENTRY_OPTIONS is only declared, but should be promoted into settings"
settings.SENTRY_OPTIONS = {
'system.secret-key': 'my-system-secret-key',
'mail.backend': 'my-mail-backend',
'mail.host': 'my-mail-host',
'mail.port': 123,
'mail.username': '******',
'mail.password': '******',
'mail.use-tls': True,
'mail.from': 'my-mail-from',
'mail.subject-prefix': 'my-mail-subject-prefix',
}
bootstrap_options(settings)
assert settings.SECRET_KEY == 'my-system-secret-key'
assert settings.EMAIL_BACKEND == 'my-mail-backend'
assert settings.EMAIL_HOST == 'my-mail-host'
assert settings.EMAIL_PORT == 123
assert settings.EMAIL_HOST_USER == 'my-mail-username'
assert settings.EMAIL_HOST_PASSWORD == 'my-mail-password'
assert settings.EMAIL_USE_TLS is True
assert settings.SERVER_EMAIL == 'my-mail-from'
assert settings.EMAIL_SUBJECT_PREFIX == 'my-mail-subject-prefix'
def test_bootstrap_options_empty_file(settings, config_yml):
config_yml.write("")
bootstrap_options(settings, str(config_yml))
assert settings.SENTRY_OPTIONS == {}
def test_initialize_app(settings):
"Just a sanity check of the full initialization process"
settings.SENTRY_OPTIONS = {'system.secret-key': 'secret-key'}
bootstrap_options(settings)
apply_legacy_settings(settings)
def test_bootstrap_options_empty_file(settings, config_yml):
config_yml.write('')
bootstrap_options(settings, six.text_type(config_yml))
assert settings.SENTRY_OPTIONS == {}
def test_bootstrap_options_missing_file(settings):
bootstrap_options(settings, 'this-file-does-not-exist-xxxxxxxxxxxxxx.yml')
assert settings.SENTRY_OPTIONS == {}
def test_bootstrap_options_mail_aliases(settings):
settings.SENTRY_OPTIONS = {
'mail.backend': 'dummy',
}
bootstrap_options(settings)
assert settings.EMAIL_BACKEND == 'alias-for-dummy'
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('RECAPTCHA_TESTING', 'True')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get('DB', 'postgres')
if test_db == 'mysql':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.mysql',
'NAME': 'sentry',
'USER': '******',
'HOST': '127.0.0.1',
})
# mysql requires running full migration all the time
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'postgres':
settings.DATABASES['default'].update({
'ENGINE': 'sentry.db.postgres',
'USER': '******',
'NAME': 'sentry',
})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'sqlite':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
})
settings.SOUTH_TESTS_MIGRATE = os.environ.get('SENTRY_SOUTH_TESTS_MIGRATE', '1') == '1'
else:
raise RuntimeError('oops, wrong database: %r' % test_db)
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + (
'tests',
)
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
settings.RECAPTCHA_PUBLIC_KEY = 'a' * 40
settings.RECAPTCHA_PRIVATE_KEY = 'b' * 40
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DEBUG_VIEWS = True
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
from sentry.runner.initializer import (
bootstrap_options, configure_structlog, initialize_receivers, fix_south,
bind_cache_to_option_store)
bootstrap_options(settings)
configure_structlog()
fix_south(settings)
bind_cache_to_option_store()
initialize_receivers()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
# override docs which are typically synchronized from an upstream server
# to ensure tests are consistent
os.environ.setdefault(
'INTEGRATION_DOC_FOLDER',
os.path.join(TEST_ROOT, 'fixtures', 'integration-docs'))
from sentry.utils import integrationdocs
integrationdocs.DOC_FOLDER = os.environ['INTEGRATION_DOC_FOLDER']
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get('DB', 'postgres')
if test_db == 'mysql':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.mysql',
'NAME': 'sentry',
'USER': '******',
'HOST': '127.0.0.1',
})
# mysql requires running full migration all the time
elif test_db == 'postgres':
settings.DATABASES['default'].update({
'ENGINE': 'sentry.db.postgres',
'USER': '******',
'NAME': 'sentry',
})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
elif test_db == 'sqlite':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
})
else:
raise RuntimeError('oops, wrong database: %r' % test_db)
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ('tests', )
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
settings.AUTH_PASSWORD_VALIDATORS = []
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
settings.SENTRY_OPTIONS['cloudflare.secret-key'] = 'cloudflare-secret-key'
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
if settings.SENTRY_NEWSLETTER == 'sentry.newsletter.base.Newsletter':
settings.SENTRY_NEWSLETTER = 'sentry.newsletter.dummy.DummyNewsletter'
settings.SENTRY_NEWSLETTER_OPTIONS = {}
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DEBUG_VIEWS = True
settings.SENTRY_ENCRYPTION_SCHEMES = ()
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
'slack.client-id': 'slack-client-id',
'slack.client-secret': 'slack-client-secret',
'slack.verification-token': 'slack-verification-token',
'github-app.name': 'sentry-test-app',
'github-app.client-id': 'github-client-id',
'github-app.client-secret': 'github-client-secret',
'vsts.client-id': 'vsts-client-id',
'vsts.client-secret': 'vsts-client-secret',
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
if not settings.SOUTH_TESTS_MIGRATE:
settings.INSTALLED_APPS = tuple(i for i in settings.INSTALLED_APPS
if i != 'south')
from sentry.runner.initializer import (bootstrap_options,
configure_structlog,
initialize_receivers, fix_south,
bind_cache_to_option_store,
setup_services)
bootstrap_options(settings)
configure_structlog()
fix_south(settings)
bind_cache_to_option_store()
initialize_receivers()
setup_services()
register_extensions()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault("_SENTRY_SKIP_CONFIGURATION", "1")
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sentry.conf.server")
# override docs which are typically synchronized from an upstream server
# to ensure tests are consistent
os.environ.setdefault(
"INTEGRATION_DOC_FOLDER",
os.path.join(TEST_ROOT, "fixtures", "integration-docs"))
from sentry.utils import integrationdocs
integrationdocs.DOC_FOLDER = os.environ["INTEGRATION_DOC_FOLDER"]
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get("DB", "postgres")
if test_db == "postgres":
settings.DATABASES["default"].update({
"ENGINE": "sentry.db.postgres",
"USER": "******",
"NAME": "sentry",
"HOST": "127.0.0.1",
})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
else:
raise RuntimeError("oops, wrong database: %r" % test_db)
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ("tests", )
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = "sentry.cache.django.DjangoCache"
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
"django.contrib.auth.hashers.MD5PasswordHasher"
]
settings.AUTH_PASSWORD_VALIDATORS = []
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index("sentry.middleware.sudo.SudoMiddleware")
middleware[sudo] = "sentry.testutils.middleware.SudoMiddleware"
settings.MIDDLEWARE_CLASSES = tuple(middleware)
settings.SENTRY_OPTIONS["cloudflare.secret-key"] = "cloudflare-secret-key"
# enable draft features
settings.SENTRY_OPTIONS["mail.enable-replies"] = True
settings.SENTRY_ALLOW_ORIGIN = "*"
settings.SENTRY_TSDB = "sentry.tsdb.inmemory.InMemoryTSDB"
settings.SENTRY_TSDB_OPTIONS = {}
if settings.SENTRY_NEWSLETTER == "sentry.newsletter.base.Newsletter":
settings.SENTRY_NEWSLETTER = "sentry.newsletter.dummy.DummyNewsletter"
settings.SENTRY_NEWSLETTER_OPTIONS = {}
settings.BROKER_BACKEND = "memory"
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DEBUG_VIEWS = True
settings.SENTRY_ENCRYPTION_SCHEMES = ()
settings.DISABLE_RAVEN = True
settings.CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.locmem.LocMemCache"
},
"nodedata": {
"BACKEND": "django.core.cache.backends.locmem.LocMemCache"
},
}
if os.environ.get("USE_SNUBA", False):
settings.SENTRY_SEARCH = "sentry.search.snuba.EventsDatasetSnubaSearchBackend"
settings.SENTRY_TSDB = "sentry.tsdb.redissnuba.RedisSnubaTSDB"
settings.SENTRY_EVENTSTREAM = "sentry.eventstream.snuba.SnubaEventStream"
if not hasattr(settings, "SENTRY_OPTIONS"):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
"redis.clusters": {
"default": {
"hosts": {
0: {
"db": 9
}
}
}
},
"mail.backend": "django.core.mail.backends.locmem.EmailBackend",
"system.url-prefix": "http://testserver",
"slack.client-id": "slack-client-id",
"slack.client-secret": "slack-client-secret",
"slack.verification-token": "slack-verification-token",
"github-app.name": "sentry-test-app",
"github-app.client-id": "github-client-id",
"github-app.client-secret": "github-client-secret",
"vsts.client-id": "vsts-client-id",
"vsts.client-secret": "vsts-client-secret",
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch("socket.getfqdn", return_value="localhost")
patcher.start()
if not settings.MIGRATIONS_TEST_MIGRATE:
# Migrations for the "sentry" app take a long time to run, which makes test startup time slow in dev.
# This is a hack to force django to sync the database state from the models rather than use migrations.
settings.MIGRATION_MODULES["sentry"] = None
from sentry.runner.initializer import (
bind_cache_to_option_store,
bootstrap_options,
configure_structlog,
initialize_receivers,
monkeypatch_model_unpickle,
monkeypatch_django_migrations,
setup_services,
)
bootstrap_options(settings)
configure_structlog()
monkeypatch_model_unpickle()
import django
django.setup()
monkeypatch_django_migrations()
bind_cache_to_option_store()
initialize_receivers()
setup_services()
register_extensions()
from sentry.utils.redis import clusters
with clusters.get("default").all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def test_bootstrap_options_mail_aliases(settings):
settings.SENTRY_OPTIONS = {"mail.backend": "dummy"}
bootstrap_options(settings)
assert settings.EMAIL_BACKEND == "alias-for-dummy"
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault("_SENTRY_SKIP_CONFIGURATION", "1")
os.environ.setdefault("RECAPTCHA_TESTING", "True")
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sentry.conf.server")
settings.SOUTH_TESTS_MIGRATE = os.environ.get("SENTRY_SOUTH_TESTS_MIGRATE", "1") == "1"
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get("DB", "postgres")
if test_db == "mysql":
settings.DATABASES["default"].update(
{"ENGINE": "django.db.backends.mysql", "NAME": "sentry", "USER": "******"}
)
# mysql requires running full migration all the time
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == "postgres":
settings.DATABASES["default"].update({"ENGINE": "sentry.db.postgres", "USER": "******", "NAME": "sentry"})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == "sqlite":
settings.DATABASES["default"].update({"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"})
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ("tests",)
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = "sentry.cache.django.DjangoCache"
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index("sentry.middleware.sudo.SudoMiddleware")
middleware[sudo] = "sentry.testutils.middleware.SudoMiddleware"
settings.MIDDLEWARE_CLASSES = tuple(middleware)
# enable draft features
settings.SENTRY_OPTIONS["mail.enable-replies"] = True
settings.SENTRY_ALLOW_ORIGIN = "*"
settings.SENTRY_TSDB = "sentry.tsdb.inmemory.InMemoryTSDB"
settings.SENTRY_TSDB_OPTIONS = {}
settings.RECAPTCHA_PUBLIC_KEY = "a" * 40
settings.RECAPTCHA_PRIVATE_KEY = "b" * 40
settings.BROKER_BACKEND = "memory"
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DISABLE_RAVEN = True
settings.CACHES = {"default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"}}
if not hasattr(settings, "SENTRY_OPTIONS"):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update(
{
"redis.clusters": {"default": {"hosts": {0: {"db": 9}}}},
"mail.backend": "django.core.mail.backends.locmem.EmailBackend",
"system.url-prefix": "http://testserver",
}
)
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch("socket.getfqdn", return_value="localhost")
patcher.start()
from sentry.runner.initializer import bootstrap_options, initialize_receivers, fix_south, bind_cache_to_option_store
bootstrap_options(settings)
fix_south(settings)
bind_cache_to_option_store()
initialize_receivers()
from sentry.utils.redis import clusters
with clusters.get("default").all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def test_initialize_app(settings):
"Just a sanity check of the full initialization process"
bootstrap_options(settings)
apply_legacy_settings(settings)
def pytest_configure(config):
if config.option.log_level:
os.environ['CLIMS_LOG_LEVEL'] = config.option.log_level
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
# override docs which are typically synchronized from an upstream server
# to ensure tests are consistent
os.environ.setdefault(
'INTEGRATION_DOC_FOLDER',
os.path.join(TEST_ROOT, 'fixtures', 'integration-docs'))
from sentry.utils import integrationdocs
integrationdocs.DOC_FOLDER = os.environ['INTEGRATION_DOC_FOLDER']
# Configure the test database
settings.DATABASES['default'].update({
'ENGINE': 'sentry.db.postgres',
'PORT':
'15433', # Docker image for the test database is exposed at 5433
'USER': '******',
'NAME': 'clims', # Django will add the test_ prefix
})
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ('tests', )
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
settings.AUTH_PASSWORD_VALIDATORS = []
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
settings.SENTRY_OPTIONS['cloudflare.secret-key'] = 'cloudflare-secret-key'
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
if settings.SENTRY_NEWSLETTER == 'sentry.newsletter.base.Newsletter':
settings.SENTRY_NEWSLETTER = 'sentry.newsletter.dummy.DummyNewsletter'
settings.SENTRY_NEWSLETTER_OPTIONS = {}
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DEBUG_VIEWS = True
settings.SENTRY_ENCRYPTION_SCHEMES = ()
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
# Use a dedicated Camunda instance for integration tests:
settings.CAMUNDA_API_URL = "http://localhost:8081/engine-rest/"
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
'slack.client-id': 'slack-client-id',
'slack.client-secret': 'slack-client-secret',
'slack.verification-token': 'slack-verification-token',
'github-app.name': 'sentry-test-app',
'github-app.client-id': 'github-client-id',
'github-app.client-secret': 'github-client-secret',
'vsts.client-id': 'vsts-client-id',
'vsts.client-secret': 'vsts-client-secret',
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
from sentry.runner.initializer import (bootstrap_options,
initialize_receivers, fix_south,
bind_cache_to_option_store,
setup_services)
from clims.logs import configure_logging
bootstrap_options(settings)
configure_logging()
fix_south(settings)
import django
if hasattr(django, 'setup'):
django.setup()
bind_cache_to_option_store()
initialize_receivers()
setup_services()
for setup, _ in tasks:
if setup:
setup()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def test_bootstrap_options_mail_aliases(settings):
settings.SENTRY_OPTIONS = {"mail.backend": "dummy"}
bootstrap_options(settings)
assert settings.EMAIL_BACKEND == "alias-for-dummy"
def test_bootstrap_options_empty_file(settings, config_yml):
config_yml.write("")
bootstrap_options(settings, str(config_yml))
assert settings.SENTRY_OPTIONS == {}
def test_initialize_app(settings):
"Just a sanity check of the full initialization process"
bootstrap_options(settings)
apply_legacy_settings(settings)
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('RECAPTCHA_TESTING', 'True')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
settings.SOUTH_TESTS_MIGRATE = os.environ.get('SENTRY_SOUTH_TESTS_MIGRATE',
'1') == '1'
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get('DB', 'postgres')
if test_db == 'mysql':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.mysql',
'NAME': 'sentry',
'USER': '******',
})
# mysql requires running full migration all the time
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'postgres':
settings.DATABASES['default'].update({
'ENGINE': 'sentry.db.postgres',
'USER': '******',
'NAME': 'sentry',
})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'sqlite':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
})
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ('tests', )
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
settings.RECAPTCHA_PUBLIC_KEY = 'a' * 40
settings.RECAPTCHA_PRIVATE_KEY = 'b' * 40
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
from sentry.runner.initializer import (bootstrap_options,
initialize_receivers, fix_south,
bind_cache_to_option_store)
bootstrap_options(settings)
fix_south(settings)
bind_cache_to_option_store()
initialize_receivers()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
# override docs which are typically synchronized from an upstream server
# to ensure tests are consistent
os.environ.setdefault(
'INTEGRATION_DOC_FOLDER',
os.path.join(
TEST_ROOT,
'fixtures',
'integration-docs'))
from sentry.utils import integrationdocs
integrationdocs.DOC_FOLDER = os.environ['INTEGRATION_DOC_FOLDER']
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get('DB', 'postgres')
if test_db == 'mysql':
settings.DATABASES['default'].update(
{
'ENGINE': 'django.db.backends.mysql',
'NAME': 'sentry',
'USER': '******',
'HOST': '127.0.0.1',
}
)
# mysql requires running full migration all the time
elif test_db == 'postgres':
settings.DATABASES['default'].update(
{
'ENGINE': 'sentry.db.postgres',
'USER': '******',
'NAME': 'sentry',
'HOST': '127.0.0.1',
}
)
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
elif test_db == 'sqlite':
settings.DATABASES['default'].update(
{
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
)
else:
raise RuntimeError('oops, wrong database: %r' % test_db)
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + ('tests', )
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
settings.AUTH_PASSWORD_VALIDATORS = []
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
settings.SENTRY_OPTIONS['cloudflare.secret-key'] = 'cloudflare-secret-key'
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
if settings.SENTRY_NEWSLETTER == 'sentry.newsletter.base.Newsletter':
settings.SENTRY_NEWSLETTER = 'sentry.newsletter.dummy.DummyNewsletter'
settings.SENTRY_NEWSLETTER_OPTIONS = {}
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DEBUG_VIEWS = True
settings.SENTRY_ENCRYPTION_SCHEMES = ()
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update(
{
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
'slack.client-id': 'slack-client-id',
'slack.client-secret': 'slack-client-secret',
'slack.verification-token': 'slack-verification-token',
'github-app.name': 'sentry-test-app',
'github-app.client-id': 'github-client-id',
'github-app.client-secret': 'github-client-secret',
'vsts.client-id': 'vsts-client-id',
'vsts.client-secret': 'vsts-client-secret',
}
)
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
if not settings.SOUTH_TESTS_MIGRATE:
settings.INSTALLED_APPS = tuple(i for i in settings.INSTALLED_APPS if i != 'south')
from sentry.runner.initializer import (
bootstrap_options, configure_structlog, initialize_receivers, fix_south,
bind_cache_to_option_store, setup_services
)
bootstrap_options(settings)
configure_structlog()
fix_south(settings)
import django
if hasattr(django, 'setup'):
django.setup()
bind_cache_to_option_store()
initialize_receivers()
setup_services()
register_extensions()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()