def handle(self, *args, **options):
from django.test.runner import DiscoverRunner as TestRunner
test_runner = TestRunner(interactive=False)
test_runner.setup_databases()
test_runner.setup_test_environment()
if is_clickhouse_enabled():
from infi.clickhouse_orm import Database # type: ignore
from posthog.settings import (
CLICKHOUSE_DATABASE,
CLICKHOUSE_HTTP_URL,
CLICKHOUSE_PASSWORD,
CLICKHOUSE_REPLICATION,
CLICKHOUSE_USER,
CLICKHOUSE_VERIFY,
)
database = Database(
CLICKHOUSE_DATABASE,
db_url=CLICKHOUSE_HTTP_URL,
username=CLICKHOUSE_USER,
password=CLICKHOUSE_PASSWORD,
verify_ssl_cert=CLICKHOUSE_VERIFY,
)
try:
database.create_database()
except:
pass
database.migrate("ee.clickhouse.migrations",
replicated=CLICKHOUSE_REPLICATION)
class DjangoAutoTestSuite(unittest.TestSuite):
"""
This test suite configures django settings (which should be in test_settings.py), and starts a test runner.
It allows us to run the django tests with setup.py test.
"""
def __init__(self, *args, **kwargs):
self._configure()
self.test_runner = DiscoverRunner()
tests = self.test_runner.build_suite()
super(DjangoAutoTestSuite, self).__init__(tests=tests, *args, **kwargs)
self.test_runner.setup_test_environment()
self.test_dbs = self.test_runner.setup_databases()
def _configure(self):
test_settings = importlib.import_module("test_settings")
setting_attrs = {
attr: getattr(test_settings, attr)
for attr in dir(test_settings)
if "__" not in attr
}
if not django.conf.settings.configured:
django.conf.settings.configure(**setting_attrs)
django.setup()
def run(self, result_obj, *args, **kwargs):
result = super(DjangoAutoTestSuite, self).run(result_obj, *args, **kwargs)
self.test_runner.teardown_databases(self.test_dbs)
self.test_runner.teardown_test_environment()
return result
def setup():
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
from django.test.runner import DiscoverRunner
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
from django.test.runner import DiscoverRunner
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def create_database(server):
"""
:param server:
:return:
"""
# assert_test_database()
world.test_runner = DiscoverRunner(interactive=False)
DiscoverRunner.setup_test_environment(world.test_runner)
world.create_db = DiscoverRunner.setup_databases(world.test_runner)
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def handle(self, *args, **options):
# Configure django environment
django_test_runner = DiscoverRunner()
django_test_runner.setup_test_environment()
old_config = django_test_runner.setup_databases()
# Run Behave tests
behave_main(args=sys.argv[2:])
# Teardown django environment
django_test_runner.teardown_databases(old_config)
django_test_runner.teardown_test_environment()
def handle(self, *args, **options):
# Configure django environment
django_test_runner = DiscoverRunner()
django_test_runner.setup_test_environment()
old_config = django_test_runner.setup_databases()
# Run Behave tests
behave_main(args=sys.argv[2:])
# Teardown django environment
django_test_runner.teardown_databases(old_config)
django_test_runner.teardown_test_environment()
def setup():
global test_runner
global old_config
# If you want to support Django 1.5 and older, you need
# this try-except block.
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
def setup():
global test_runner
global old_config
try:
# DjangoTestSuiteRunner was deprecated in django 1.8:
# https://docs.djangoproject.com/en/1.8/internals/deprecation/#deprecation-removed-in-1-8
from django.test.runner import DiscoverRunner as TestSuiteRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestSuiteRunner
test_runner = TestSuiteRunner()
test_runner.setup_test_environment()
test_runner.setup_databases()
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
# Django 1.5 did not have the DiscoverRunner
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
# Django 1.5 did not have the DiscoverRunner
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
global test_runner
global old_config
from ella.utils.installedapps import call_modules
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
try:
django.setup()
except AttributeError:
pass
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
call_modules(('register', ))
def setup():
try:
from elasticsearch import Elasticsearch, ElasticsearchException
except ImportError:
raise unittest.SkipTest("elasticsearch-py not installed.")
es = Elasticsearch(settings.HAYSTACK_CONNECTIONS['elasticsearch']['URL'])
try:
es.info()
except ElasticsearchException as e:
raise unittest.SkipTest(
"elasticsearch not running on %r" %
settings.HAYSTACK_CONNECTIONS['elasticsearch']['URL'], e)
global test_runner
global old_config
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def handle(self, *args, **options):
if not TEST:
raise ValueError(
"TEST environment variable needs to be set for this command to function"
)
from django.test.runner import DiscoverRunner as TestRunner
test_runner = TestRunner(interactive=False)
test_runner.setup_databases()
test_runner.setup_test_environment()
from infi.clickhouse_orm import Database
from posthog.settings import (
CLICKHOUSE_CLUSTER,
CLICKHOUSE_DATABASE,
CLICKHOUSE_HTTP_URL,
CLICKHOUSE_PASSWORD,
CLICKHOUSE_REPLICATION,
CLICKHOUSE_USER,
CLICKHOUSE_VERIFY,
)
database = Database(
CLICKHOUSE_DATABASE,
db_url=CLICKHOUSE_HTTP_URL,
username=CLICKHOUSE_USER,
password=CLICKHOUSE_PASSWORD,
cluster=CLICKHOUSE_CLUSTER,
verify_ssl_cert=CLICKHOUSE_VERIFY,
)
try:
database.create_database()
except:
pass
database.migrate("ee.clickhouse.migrations",
replicated=CLICKHOUSE_REPLICATION)
def pytest_configure(config):
from django.conf import settings
from django.test.runner import DiscoverRunner
settings.configure(
DEBUG_PROPAGATE_EXCEPTIONS=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
SITE_ID=1,
SECRET_KEY='not very secret in tests',
USE_I18N=True,
USE_L10N=True,
STATIC_URL='/static/',
ROOT_URLCONF='tests.urls',
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
'OPTIONS': {
"debug": True, # We want template errors to raise
}
},
],
MIDDLEWARE=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
INSTALLED_APPS=(
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.staticfiles',
'drf_magic',
'tests',
) + tuple(map(lambda x: f'{TEST_PREFIX}.{x}', test_apps)),
SWAGGER_SETTINGS={
'DEFAULT_GENERATOR_CLASS': 'drf_magic.docs.generators.VersionAgnosticSchemaGenerator',
'DEFAULT_AUTO_SCHEMA_CLASS': 'drf_magic.docs.schema.SmartSummaryAutoSchema',
},
YASG_SCHEMA={
'TITLE': 'Test Docs',
'VERSION': '0.1.0',
'DESCRIPTION_PATH': os.path.join(os.path.dirname(__file__), 'dummy_api_desc.md'),
},
PASSWORD_HASHERS=(
'django.contrib.auth.hashers.MD5PasswordHasher',
),
)
if config.getoption('--no-pkgroot'):
sys.path.pop(0)
# import drf_magic before pytest re-adds the package root directory.
import drf_magic
package_dir = os.path.join(os.getcwd(), 'drf_magic')
assert not drf_magic.__file__.startswith(package_dir)
# Manifest storage will raise an exception if static files are not present (ie, a packaging failure).
if config.getoption('--staticfiles'):
import drf_magic
settings.STATIC_ROOT = os.path.join(os.path.dirname(drf_magic.__file__), 'static-root')
settings.STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'
django.setup()
for app in test_apps:
management.call_command('makemigrations', app)
runner = DiscoverRunner()
runner.setup_test_environment()
runner.setup_databases()
if config.getoption('--staticfiles'):
management.call_command('collectstatic', verbosity=0, interactive=False)
class TestMiddleWare(TestCase):
def setUp(self):
# Simple class that doesn't output to the standard output
class StringIOTextRunner(TextTestRunner):
def __init__(self, *args, **kwargs):
kwargs['stream'] = StringIO()
super().__init__(*args, **kwargs)
self.test_runner = DiscoverRunner()
self.test_runner.test_runner = StringIOTextRunner
def tearDown(self):
try:
os.remove(RequestQueryCountConfig.get_setting('DETAIL_PATH'))
except FileNotFoundError:
pass
try:
os.remove(RequestQueryCountConfig.get_setting('SUMMARY_PATH'))
except FileNotFoundError:
pass
def test_middleware_called(self):
with mock.patch('test_query_counter.middleware.Middleware',
new=MagicMock(wraps=Middleware)) as mocked:
self.client.get('/url-1')
self.assertEqual(mocked.call_count, 1)
def test_case_injected_one_test(self):
class Test(TestCase):
def test_foo(self):
self.client.get('/url-1')
self.test_runner.setup_test_environment()
self.test_runner.run_suite(TestLoader().loadTestsFromTestCase(
testCaseClass=Test))
self.test_runner.teardown_test_environment()
self.assertEqual(RequestQueryCountManager.queries.total, 1)
def test_case_injected_two_tests(self):
class Test(TestCase):
def test_foo(self):
self.client.get('/url-1')
def test_bar(self):
self.client.get('/url-2')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertEqual(RequestQueryCountManager.queries.total, 2)
@override_settings(TEST_QUERY_COUNTER={'ENABLE': False})
def test_case_disable_setting(self):
class Test(TestCase):
def test_foo(self):
self.client.get('/url-1')
def test_bar(self):
self.client.get('/url-2')
self.test_runner.run_tests(
None,
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertIsNone(RequestQueryCountManager.queries)
@override_settings(TEST_QUERY_COUNTER={'ENABLE': False})
def test_disabled(self):
mock_get_response = object()
with self.assertRaises(MiddlewareNotUsed):
Middleware(mock_get_response)
def test_json_exists(self):
class Test(TestCase):
def test_foo(self):
self.client.get('/url-1')
self.assertFalse(path.exists(
RequestQueryCountConfig.get_setting('DETAIL_PATH'))
)
self.test_runner.run_tests(
None,
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertTrue(path.exists(
RequestQueryCountConfig.get_setting('DETAIL_PATH'))
)
class TestRunnerTest(TestCase):
def setUp(self):
# Simple class that doesn't output to the standard output
class StringIOTextRunner(TextTestRunner):
def __init__(self, *args, **kwargs):
kwargs['stream'] = StringIO()
super().__init__(*args, **kwargs)
self.test_runner = DiscoverRunner()
self.test_runner.test_runner = StringIOTextRunner
def tearDown(self):
try:
os.remove(RequestQueryCountConfig.get_setting('DETAIL_PATH'))
except FileNotFoundError:
pass
try:
os.remove(RequestQueryCountConfig.get_setting('SUMMARY_PATH'))
except FileNotFoundError:
pass
def test_empty_test(self):
class Test(TestCase):
def test_foo(self):
pass
def test_bar(self):
pass
self.test_runner.setup_test_environment()
self.test_runner.run_suite(TestLoader().loadTestsFromTestCase(
testCaseClass=Test)
)
self.test_runner.teardown_test_environment()
# check for empty tests
self.assertIsNotNone(RequestQueryCountManager, 'queries')
self.assertIsInstance(RequestQueryCountManager.queries,
TestResultQueryContainer)
self.assertEqual(RequestQueryCountManager.queries.total, 0)
# check if files are generated
self.assertTrue(path.exists(
RequestQueryCountConfig.get_setting('SUMMARY_PATH'))
)
self.assertTrue(path.isfile(
RequestQueryCountConfig.get_setting('SUMMARY_PATH'))
)
self.assertTrue(path.exists(
RequestQueryCountConfig.get_setting('DETAIL_PATH'))
)
self.assertTrue(path.isfile(
RequestQueryCountConfig.get_setting('DETAIL_PATH'))
)
@classmethod
def get_id(cls, test_class, method_name):
return "{}.{}.{}".format(test_class.__module__,
test_class.__qualname__,
method_name)
def test_runner_include_queries(self):
class Test(TestCase):
def test_foo(self):
self.client.get('/url-1')
self.test_runner.run_tests(
None,
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
# Assert it ran one test
self.assertEqual(len(RequestQueryCountManager.queries.queries_by_testcase), 1)
test_foo_id = self.get_id(Test, 'test_foo')
self.assertIn(test_foo_id,
RequestQueryCountManager.queries.queries_by_testcase)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[test_foo_id].total, 1
)
def test_excluded_test(self):
class Test(TestCase):
@exclude_query_count()
def test_foo(self):
self.client.get('/url-1')
def test_bar(self):
self.client.get('/url-1')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
# Assert test_foo has excluded queries
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_foo')].total,
0
)
# Assert test_bar has some queries
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_bar')].total,
1
)
def test_excluded_class(self):
@exclude_query_count()
class Test(TestCase):
def test_foo(self):
self.client.get('path-1')
def test_bar(self):
self.client.get('path-1')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
# Assert test_foo has excluded queries
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_foo')].total,
0
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_bar')].total,
0
)
def test_conditional_exclude(self):
class Test(TestCase):
@exclude_query_count(path='url-2')
def test_exclude_path(self):
self.client.get('/url-1')
self.client.post('/url-2')
@exclude_query_count(method='post')
def test_exclude_method(self):
self.client.get('/url-1')
self.client.post('/url-2')
@exclude_query_count(count=2)
def test_exclude_count(self):
self.client.get('/url-1')
self.client.post('/url-2')
# succesive url are additive
self.client.put('/url-3')
self.client.put('/url-3')
self.client.put('/url-3')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_exclude_path')].total,
1
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_exclude_method')].total,
1
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_exclude_count')].total,
3
)
def test_nested_method_exclude(self):
class Test(TestCase):
@exclude_query_count(path='url-1')
@exclude_query_count(method='post')
@exclude_query_count(path='url-3')
def test_foo(self):
self.client.get('/url-1')
self.client.post('/url-2')
self.client.put('/url-3')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_foo')].total,
0
)
def test_nested_class_method_exclude(self):
@exclude_query_count(path='url-1')
class Test(TestCase):
@exclude_query_count(method='post')
def test_foo(self):
self.client.get('/url-1')
self.client.post('/url-2')
self.client.put('/url-3')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_foo')].total,
1
)
def test_custom_setup_teardown(self):
class Test(TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_foo(self):
self.client.get('/url-1')
self.test_runner.run_suite(
TestLoader().loadTestsFromTestCase(testCaseClass=Test)
)
self.assertIn(
self.get_id(Test, 'test_foo'),
RequestQueryCountManager.queries.queries_by_testcase
)
self.assertEqual(
RequestQueryCountManager.queries.queries_by_testcase[
self.get_id(Test, 'test_foo')].total,
1
)
class DjangoPlugin(Fixtures):
def __init__(self, config):
self.config = config
self.check_markers()
self.configure()
self.original_connection_close = {}
try:
self.live_server_class = import_module(config.option.liveserver_class)
except ImportError:
liveserver_class = config.option.liveserver_class.split(".")
self.live_server_class = getattr(import_module(".".join(liveserver_class[:-1])), liveserver_class[-1])
def check_markers(self):
self.skip_trans = False
if "not transaction" in self.config.option.markexpr or self.config.option.skip_trans:
self.skip_trans = True
def configure(self):
self.runner = DiscoverRunner(interactive=False, verbosity=self.config.option.verbose)
self.runner.setup_test_environment()
management.get_commands() # load all commands first
is_sqlite = settings.DATABASES.get("default", {}).get("ENGINE", "").endswith("sqlite3")
wrap_database()
db_postfix = getattr(self.config, "slaveinput", {}).get("slaveid", "")
monkey_patch_creation_for_db_reuse(db_postfix if not is_sqlite else None, force=self.config.option.create_db)
migrate_db = self.config.option.migrate or self.config.option.create_db
can_migrate = "south" in settings.INSTALLED_APPS
if can_migrate:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
try:
self.runner.setup_databases()
if migrate_db and can_migrate:
management.call_command("migrate", verbosity=self.config.option.verbose)
except Exception:
raise pytest.UsageError(sys.exc_info()[1])
def pytest_pycollect_makemodule(self, path, parent):
return Module(path, parent)
@pytest.mark.tryfirst # or trylast as it was ?
def pytest_sessionstart(self, session):
# turn off debug toolbar to speed up testing
middlewares = []
for mid in settings.MIDDLEWARE_CLASSES:
if not mid.startswith("debug_toolbar"):
middlewares.append(mid)
settings.MIDDLEWARE_CLASSES = middlewares
for db in connections:
conn = connections[db]
conn.set_autocommit(False, force_begin_transaction_with_broken_autocommit=True)
conn.in_atomic_block = True
self.original_connection_close[db] = conn.close
conn.close = nop
def pytest_sessionfinish(self, session):
self.runner.teardown_test_environment()
for db in connections:
connections[db].in_atomic_block = False
transaction.rollback(using=db)
connections[db].in_atomic_block = True
if self.original_connection_close:
connections[db].close = self.original_connection_close[db]
@pytest.mark.trylast
def pytest_collection_modifyitems(self, items):
trans_items = []
non_trans = []
for index, item in enumerate(items):
if item.module.has_transactions:
trans_items.append(item)
else:
non_trans.append(item)
sorted_trans = []
for module, iterator in groupby(trans_items[:], lambda x: x.module):
for item, it in groupby(iterator, lambda x: x.cls and is_transaction_test(x.cls)):
sorted_trans.extend(it)
sorted_by_modules = non_trans + sorted_trans
items[:] = sorted_by_modules
def restore_database(self, item, nextitem):
for db in connections:
management.call_command("flush", verbosity=0, interactive=False, database=db)
all(i.setup() for i in item.listchain())
def pytest_runtest_protocol(self, item, nextitem):
"""Clear database if previous test item was from different module and it
was TransactionTestCase. then run setup on all ascending modules
"""
if item.cls is not None and is_transaction_test(item.cls):
if nextitem is None or nextitem.module != item.module:
if nextitem is not None:
item._request.addfinalizer(lambda: self.restore_database(item, nextitem))
@pytest.mark.tryfirst
def pytest_pycollect_makeitem(self, collector, name, obj):
"""Shadow builtin unittest makeitem with patched class and function
"""
try:
isunit = issubclass(obj, unittest.TestCase)
except KeyboardInterrupt:
raise
except Exception:
pass
else:
if isunit:
return SUnitTestCase(name, parent=collector)
@pytest.mark.tryfirst
def pytest_runtest_setup(self, item):
if "transaction" in item.keywords and self.skip_trans:
pytest.skip("excluding transaction test")
def pytest_runtest_call(self, item, __multicall__):
return __multicall__.execute()
