From 4ee67a1632f41a873d997ae15ac0a2eccca04430 Mon Sep 17 00:00:00 2001 From: David Cramer Date: Tue, 14 Jun 2011 12:38:55 -0700 Subject: Move test suite into parent namespace --- debug_toolbar/runtests.py | 47 ------ debug_toolbar/tests/__init__.py | 1 - debug_toolbar/tests/templates/404.html | 0 debug_toolbar/tests/tests.py | 284 --------------------------------- debug_toolbar/tests/urls.py | 14 -- debug_toolbar/tests/views.py | 7 - runtests.py | 50 ++++++ setup.py | 4 +- tests/__init__.py | 0 tests/models.py | 0 tests/templates/404.html | 0 tests/tests.py | 284 +++++++++++++++++++++++++++++++++ tests/urls.py | 14 ++ tests/views.py | 7 + 14 files changed, 357 insertions(+), 355 deletions(-) delete mode 100644 debug_toolbar/runtests.py delete mode 100644 debug_toolbar/tests/__init__.py delete mode 100644 debug_toolbar/tests/templates/404.html delete mode 100644 debug_toolbar/tests/tests.py delete mode 100644 debug_toolbar/tests/urls.py delete mode 100644 debug_toolbar/tests/views.py create mode 100644 runtests.py create mode 100644 tests/__init__.py create mode 100644 tests/models.py create mode 100644 tests/templates/404.html create mode 100644 tests/tests.py create mode 100644 tests/urls.py create mode 100644 tests/views.py diff --git a/debug_toolbar/runtests.py b/debug_toolbar/runtests.py deleted file mode 100644 index f16882a..0000000 --- a/debug_toolbar/runtests.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env python -import sys -from os.path import dirname, abspath - -from django.conf import settings - -if not settings.configured: - settings.configure( - DATABASE_ENGINE='sqlite3', - # HACK: this fixes our threaded runserver remote tests - # DATABASE_NAME='test_sentry', - # TEST_DATABASE_NAME='test_sentry', - INSTALLED_APPS=[ - 'django.contrib.auth', - 'django.contrib.admin', - 'django.contrib.contenttypes', - 'django.contrib.sessions', - 'django.contrib.sites', - - 'debug_toolbar', - - 'debug_toolbar.tests', - ], - ROOT_URLCONF='', - DEBUG=False, - SITE_ID=1, - ) - import djcelery - djcelery.setup_loader() - -from django.test.simple import run_tests - -def runtests(*test_args): - if 'south' in settings.INSTALLED_APPS: - from south.management.commands import patch_for_test_db_setup - patch_for_test_db_setup() - - if not test_args: - test_args = ['debug_toolbar'] - parent = dirname(abspath(__file__)) - sys.path.insert(0, parent) - failures = run_tests(test_args, verbosity=1, interactive=True) - sys.exit(failures) - - -if __name__ == '__main__': - runtests(*sys.argv[1:]) \ No newline at end of file diff --git a/debug_toolbar/tests/__init__.py b/debug_toolbar/tests/__init__.py deleted file mode 100644 index f853b10..0000000 --- a/debug_toolbar/tests/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from tests import * \ No newline at end of file diff --git a/debug_toolbar/tests/templates/404.html b/debug_toolbar/tests/templates/404.html deleted file mode 100644 index e69de29..0000000 diff --git a/debug_toolbar/tests/tests.py b/debug_toolbar/tests/tests.py deleted file mode 100644 index 3fc2aff..0000000 --- a/debug_toolbar/tests/tests.py +++ /dev/null @@ -1,284 +0,0 @@ -from debug_toolbar.middleware import DebugToolbarMiddleware -from debug_toolbar.panels.sql import SQLDebugPanel -from debug_toolbar.toolbar.loader import DebugToolbar -from debug_toolbar.utils.tracking import pre_dispatch, post_dispatch, callbacks - -from django.conf import settings -from django.contrib.auth.models import User -from django.test import TestCase - -from dingus import Dingus -import thread - - -class Settings(object): - """Allows you to define settings that are required for this function to work""" - - NotDefined = object() - - def __init__(self, **overrides): - self.overrides = overrides - self._orig = {} - - def __enter__(self): - for k, v in self.overrides.iteritems(): - self._orig[k] = getattr(settings, k, self.NotDefined) - setattr(settings, k, v) - - def __exit__(self, exc_type, exc_value, traceback): - for k, v in self._orig.iteritems(): - if v is self.NotDefined: - delattr(settings, k) - else: - setattr(settings, k, v) - -class BaseTestCase(TestCase): - def setUp(self): - request = Dingus('request') - toolbar = DebugToolbar(request) - - DebugToolbarMiddleware.debug_toolbars[thread.get_ident()] = toolbar - - self.request = request - self.toolbar = toolbar - -class DebugToolbarTestCase(BaseTestCase): - urls = 'debug_toolbar.tests.urls' - - def test_middleware(self): - resp = self.client.get('/execute_sql/') - self.assertEquals(resp.status_code, 200) - - def test_show_toolbar_DEBUG(self): - request = self.request - - middleware = DebugToolbarMiddleware() - - with Settings(DEBUG=True): - self.assertTrue(middleware._show_toolbar(request)) - - with Settings(DEBUG=False): - self.assertFalse(middleware._show_toolbar(request)) - - def test_show_toolbar_TEST(self): - request = self.request - - middleware = DebugToolbarMiddleware() - - with Settings(TEST=True, DEBUG=True): - self.assertFalse(middleware._show_toolbar(request)) - - with Settings(TEST=False, DEBUG=True): - self.assertTrue(middleware._show_toolbar(request)) - - def test_show_toolbar_INTERNAL_IPS(self): - request = self.request - - request.META = {'REMOTE_ADDR': '127.0.0.1'} - middleware = DebugToolbarMiddleware() - - with Settings(INTERNAL_IPS=['127.0.0.1']): - self.assertTrue(middleware._show_toolbar(request)) - - with Settings(INTERNAL_IPS=[]): - self.assertFalse(middleware._show_toolbar(request)) - - def test_request_urlconf_string(self): - request = self.request - - request.urlconf = 'debug_toolbar.tests.urls' - request.META = {'REMOTE_ADDR': '127.0.0.1'} - middleware = DebugToolbarMiddleware() - - with Settings(DEBUG=True): - middleware.process_request(request) - - self.assertFalse(isinstance(request.urlconf, basestring)) - - self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) - self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') - self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'debug_toolbar.tests.urls') - - def test_request_urlconf_string_per_request(self): - request = self.request - - request.urlconf = 'debug_toolbar.tests.urls' - request.META = {'REMOTE_ADDR': '127.0.0.1'} - middleware = DebugToolbarMiddleware() - - with Settings(DEBUG=True): - middleware.process_request(request) - request.urlconf = 'debug_toolbar.urls' - middleware.process_request(request) - - self.assertFalse(isinstance(request.urlconf, basestring)) - - self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) - self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') - self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'debug_toolbar.urls') - - def test_request_urlconf_module(self): - request = self.request - - request.urlconf = __import__('debug_toolbar.tests.urls').tests.urls - request.META = {'REMOTE_ADDR': '127.0.0.1'} - middleware = DebugToolbarMiddleware() - - with Settings(DEBUG=True): - middleware.process_request(request) - - self.assertFalse(isinstance(request.urlconf, basestring)) - - self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) - self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') - self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'debug_toolbar.tests.urls') - -class SQLPanelTestCase(BaseTestCase): - def test_recording(self): - panel = self.toolbar.get_panel(SQLDebugPanel) - self.assertEquals(len(panel._queries), 0) - - list(User.objects.all()) - - # ensure query was logged - self.assertEquals(len(panel._queries), 1) - query = panel._queries[0] - self.assertEquals(query[0], 'default') - self.assertTrue('sql' in query[1]) - self.assertTrue('duration' in query[1]) - self.assertTrue('stacktrace' in query[1]) - -def module_func(*args, **kwargs): - """Used by dispatch tests""" - return 'blah' - -class TrackingTestCase(BaseTestCase): - @classmethod - def class_method(cls, *args, **kwargs): - return 'blah' - - def class_func(self, *args, **kwargs): - """Used by dispatch tests""" - return 'blah' - - def test_pre_hook(self): - foo = {} - - @pre_dispatch(module_func) - def test(**kwargs): - foo.update(kwargs) - - self.assertTrue(hasattr(module_func, '__wrapped__')) - self.assertEquals(len(callbacks['before']), 1) - - module_func('hi', foo='bar') - - self.assertTrue('sender' in foo, foo) - # best we can do - self.assertEquals(foo['sender'].__name__, 'module_func') - self.assertTrue('start' in foo, foo) - self.assertTrue(foo['start'] > 0) - self.assertTrue('stop' not in foo, foo) - self.assertTrue('args' in foo, foo) - self.assertTrue(len(foo['args']), 1) - self.assertEquals(foo['args'][0], 'hi') - self.assertTrue('kwargs' in foo, foo) - self.assertTrue(len(foo['kwargs']), 1) - self.assertTrue('foo' in foo['kwargs']) - self.assertEquals(foo['kwargs']['foo'], 'bar') - - callbacks['before'] = {} - - @pre_dispatch(TrackingTestCase.class_func) - def test(**kwargs): - foo.update(kwargs) - - self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__')) - self.assertEquals(len(callbacks['before']), 1) - - self.class_func('hello', foo='bar') - - self.assertTrue('sender' in foo, foo) - # best we can do - self.assertEquals(foo['sender'].__name__, 'class_func') - self.assertTrue('start' in foo, foo) - self.assertTrue(foo['start'] > 0) - self.assertTrue('stop' not in foo, foo) - self.assertTrue('args' in foo, foo) - self.assertTrue(len(foo['args']), 2) - self.assertEquals(foo['args'][1], 'hello') - self.assertTrue('kwargs' in foo, foo) - self.assertTrue(len(foo['kwargs']), 1) - self.assertTrue('foo' in foo['kwargs']) - self.assertEquals(foo['kwargs']['foo'], 'bar') - - # callbacks['before'] = {} - # - # @pre_dispatch(TrackingTestCase.class_method) - # def test(**kwargs): - # foo.update(kwargs) - # - # self.assertTrue(hasattr(TrackingTestCase.class_method, '__wrapped__')) - # self.assertEquals(len(callbacks['before']), 1) - # - # TrackingTestCase.class_method() - # - # self.assertTrue('sender' in foo, foo) - # # best we can do - # self.assertEquals(foo['sender'].__name__, 'class_method') - # self.assertTrue('start' in foo, foo) - # self.assertTrue('stop' not in foo, foo) - # self.assertTrue('args' in foo, foo) - - def test_post_hook(self): - foo = {} - - @post_dispatch(module_func) - def test(**kwargs): - foo.update(kwargs) - - self.assertTrue(hasattr(module_func, '__wrapped__')) - self.assertEquals(len(callbacks['after']), 1) - - module_func('hi', foo='bar') - - self.assertTrue('sender' in foo, foo) - # best we can do - self.assertEquals(foo['sender'].__name__, 'module_func') - self.assertTrue('start' in foo, foo) - self.assertTrue(foo['start'] > 0) - self.assertTrue('stop' in foo, foo) - self.assertTrue(foo['stop'] > foo['start']) - self.assertTrue('args' in foo, foo) - self.assertTrue(len(foo['args']), 1) - self.assertEquals(foo['args'][0], 'hi') - self.assertTrue('kwargs' in foo, foo) - self.assertTrue(len(foo['kwargs']), 1) - self.assertTrue('foo' in foo['kwargs']) - self.assertEquals(foo['kwargs']['foo'], 'bar') - - callbacks['after'] = {} - - @post_dispatch(TrackingTestCase.class_func) - def test(**kwargs): - foo.update(kwargs) - - self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__')) - self.assertEquals(len(callbacks['after']), 1) - - self.class_func('hello', foo='bar') - - self.assertTrue('sender' in foo, foo) - # best we can do - self.assertEquals(foo['sender'].__name__, 'class_func') - self.assertTrue('start' in foo, foo) - self.assertTrue(foo['start'] > 0) - self.assertTrue('stop' in foo, foo) - self.assertTrue(foo['stop'] > foo['start']) - self.assertTrue('args' in foo, foo) - self.assertTrue(len(foo['args']), 2) - self.assertEquals(foo['args'][1], 'hello') - self.assertTrue('kwargs' in foo, foo) - self.assertTrue(len(foo['kwargs']), 1) - self.assertTrue('foo' in foo['kwargs']) - self.assertEquals(foo['kwargs']['foo'], 'bar') \ No newline at end of file diff --git a/debug_toolbar/tests/urls.py b/debug_toolbar/tests/urls.py deleted file mode 100644 index 7c99b03..0000000 --- a/debug_toolbar/tests/urls.py +++ /dev/null @@ -1,14 +0,0 @@ -""" -URLpatterns for the debug toolbar. - -These should not be loaded explicitly; the debug toolbar middleware will patch -this into the urlconf for the request. -""" -from django.conf.urls.defaults import * -from django.contrib import admin - -admin.autodiscover() - -urlpatterns = patterns('', - url(r'^execute_sql/$', 'debug_toolbar.tests.views.execute_sql'), -) diff --git a/debug_toolbar/tests/views.py b/debug_toolbar/tests/views.py deleted file mode 100644 index f989dcd..0000000 --- a/debug_toolbar/tests/views.py +++ /dev/null @@ -1,7 +0,0 @@ -from django.contrib.auth.models import User -from django.http import HttpResponse - -def execute_sql(request): - list(User.objects.all()) - - return HttpResponse() \ No newline at end of file diff --git a/runtests.py b/runtests.py new file mode 100644 index 0000000..b8abc5d --- /dev/null +++ b/runtests.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python +import sys +from os.path import dirname, abspath +from optparse import OptionParser + +from django.conf import settings + +if not settings.configured: + settings.configure( + DATABASE_ENGINE='sqlite3', + # HACK: this fixes our threaded runserver remote tests + # DATABASE_NAME='test_sentry', + # TEST_DATABASE_NAME='test_sentry', + INSTALLED_APPS=[ + 'django.contrib.auth', + 'django.contrib.admin', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.sites', + + 'debug_toolbar', + + 'tests', + ], + ROOT_URLCONF='', + DEBUG=False, + SITE_ID=1, + ) + +from django.test.simple import run_tests + +def runtests(*test_args, **kwargs): + if 'south' in settings.INSTALLED_APPS: + from south.management.commands import patch_for_test_db_setup + patch_for_test_db_setup() + + if not test_args: + test_args = ['tests'] + parent = dirname(abspath(__file__)) + sys.path.insert(0, parent) + failures = run_tests(test_args, verbosity=kwargs.get('verbosity', 1), interactive=kwargs.get('interactive', False), failfast=kwargs.get('failfast')) + sys.exit(failures) + +if __name__ == '__main__': + parser = OptionParser() + parser.add_option('--failfast', action='store_true', default=False, dest='failfast') + + (options, args) = parser.parse_args() + + runtests(failfast=options.failfast, *args) \ No newline at end of file diff --git a/setup.py b/setup.py index 4314988..f232b86 100644 --- a/setup.py +++ b/setup.py @@ -11,12 +11,12 @@ setup( url='https://github.com/django-debug-toolbar/django-debug-toolbar', download_url='https://github.com/django-debug-toolbar/django-debug-toolbar/downloads', license='BSD', - packages=find_packages(exclude=['ez_setup']), + packages=find_packages(exclude=('ez_setup', 'tests', 'example')), tests_require=[ 'django>=1.1,<1.4', 'dingus', ], - test_suite='debug_toolbar.runtests.runtests', + test_suite='runtests.runtests', include_package_data=True, zip_safe=False, # because we're including media that Django needs classifiers=[ diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/models.py b/tests/models.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/templates/404.html b/tests/templates/404.html new file mode 100644 index 0000000..e69de29 diff --git a/tests/tests.py b/tests/tests.py new file mode 100644 index 0000000..31b96c8 --- /dev/null +++ b/tests/tests.py @@ -0,0 +1,284 @@ +from debug_toolbar.middleware import DebugToolbarMiddleware +from debug_toolbar.panels.sql import SQLDebugPanel +from debug_toolbar.toolbar.loader import DebugToolbar +from debug_toolbar.utils.tracking import pre_dispatch, post_dispatch, callbacks + +from django.conf import settings +from django.contrib.auth.models import User +from django.test import TestCase + +from dingus import Dingus +import thread + + +class Settings(object): + """Allows you to define settings that are required for this function to work""" + + NotDefined = object() + + def __init__(self, **overrides): + self.overrides = overrides + self._orig = {} + + def __enter__(self): + for k, v in self.overrides.iteritems(): + self._orig[k] = getattr(settings, k, self.NotDefined) + setattr(settings, k, v) + + def __exit__(self, exc_type, exc_value, traceback): + for k, v in self._orig.iteritems(): + if v is self.NotDefined: + delattr(settings, k) + else: + setattr(settings, k, v) + +class BaseTestCase(TestCase): + def setUp(self): + request = Dingus('request') + toolbar = DebugToolbar(request) + + DebugToolbarMiddleware.debug_toolbars[thread.get_ident()] = toolbar + + self.request = request + self.toolbar = toolbar + +class DebugToolbarTestCase(BaseTestCase): + urls = 'tests.urls' + + def test_middleware(self): + resp = self.client.get('/execute_sql/') + self.assertEquals(resp.status_code, 200) + + def test_show_toolbar_DEBUG(self): + request = self.request + + middleware = DebugToolbarMiddleware() + + with Settings(DEBUG=True): + self.assertTrue(middleware._show_toolbar(request)) + + with Settings(DEBUG=False): + self.assertFalse(middleware._show_toolbar(request)) + + def test_show_toolbar_TEST(self): + request = self.request + + middleware = DebugToolbarMiddleware() + + with Settings(TEST=True, DEBUG=True): + self.assertFalse(middleware._show_toolbar(request)) + + with Settings(TEST=False, DEBUG=True): + self.assertTrue(middleware._show_toolbar(request)) + + def test_show_toolbar_INTERNAL_IPS(self): + request = self.request + + request.META = {'REMOTE_ADDR': '127.0.0.1'} + middleware = DebugToolbarMiddleware() + + with Settings(INTERNAL_IPS=['127.0.0.1']): + self.assertTrue(middleware._show_toolbar(request)) + + with Settings(INTERNAL_IPS=[]): + self.assertFalse(middleware._show_toolbar(request)) + + def test_request_urlconf_string(self): + request = self.request + + request.urlconf = 'tests.urls' + request.META = {'REMOTE_ADDR': '127.0.0.1'} + middleware = DebugToolbarMiddleware() + + with Settings(DEBUG=True): + middleware.process_request(request) + + self.assertFalse(isinstance(request.urlconf, basestring)) + + self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) + self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') + self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'tests.urls') + + def test_request_urlconf_string_per_request(self): + request = self.request + + request.urlconf = 'tests.urls' + request.META = {'REMOTE_ADDR': '127.0.0.1'} + middleware = DebugToolbarMiddleware() + + with Settings(DEBUG=True): + middleware.process_request(request) + request.urlconf = 'debug_toolbar.urls' + middleware.process_request(request) + + self.assertFalse(isinstance(request.urlconf, basestring)) + + self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) + self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') + self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'debug_toolbar.urls') + + def test_request_urlconf_module(self): + request = self.request + + request.urlconf = __import__('tests.urls').urls + request.META = {'REMOTE_ADDR': '127.0.0.1'} + middleware = DebugToolbarMiddleware() + + with Settings(DEBUG=True): + middleware.process_request(request) + + self.assertFalse(isinstance(request.urlconf, basestring)) + + self.assertTrue(hasattr(request.urlconf.urlpatterns[0], '_callback_str')) + self.assertEquals(request.urlconf.urlpatterns[0]._callback_str, 'debug_toolbar.views.debug_media') + self.assertEquals(request.urlconf.urlpatterns[-1].urlconf_name.__name__, 'tests.urls') + +class SQLPanelTestCase(BaseTestCase): + def test_recording(self): + panel = self.toolbar.get_panel(SQLDebugPanel) + self.assertEquals(len(panel._queries), 0) + + list(User.objects.all()) + + # ensure query was logged + self.assertEquals(len(panel._queries), 1) + query = panel._queries[0] + self.assertEquals(query[0], 'default') + self.assertTrue('sql' in query[1]) + self.assertTrue('duration' in query[1]) + self.assertTrue('stacktrace' in query[1]) + +def module_func(*args, **kwargs): + """Used by dispatch tests""" + return 'blah' + +class TrackingTestCase(BaseTestCase): + @classmethod + def class_method(cls, *args, **kwargs): + return 'blah' + + def class_func(self, *args, **kwargs): + """Used by dispatch tests""" + return 'blah' + + def test_pre_hook(self): + foo = {} + + @pre_dispatch(module_func) + def test(**kwargs): + foo.update(kwargs) + + self.assertTrue(hasattr(module_func, '__wrapped__')) + self.assertEquals(len(callbacks['before']), 1) + + module_func('hi', foo='bar') + + self.assertTrue('sender' in foo, foo) + # best we can do + self.assertEquals(foo['sender'].__name__, 'module_func') + self.assertTrue('start' in foo, foo) + self.assertTrue(foo['start'] > 0) + self.assertTrue('stop' not in foo, foo) + self.assertTrue('args' in foo, foo) + self.assertTrue(len(foo['args']), 1) + self.assertEquals(foo['args'][0], 'hi') + self.assertTrue('kwargs' in foo, foo) + self.assertTrue(len(foo['kwargs']), 1) + self.assertTrue('foo' in foo['kwargs']) + self.assertEquals(foo['kwargs']['foo'], 'bar') + + callbacks['before'] = {} + + @pre_dispatch(TrackingTestCase.class_func) + def test(**kwargs): + foo.update(kwargs) + + self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__')) + self.assertEquals(len(callbacks['before']), 1) + + self.class_func('hello', foo='bar') + + self.assertTrue('sender' in foo, foo) + # best we can do + self.assertEquals(foo['sender'].__name__, 'class_func') + self.assertTrue('start' in foo, foo) + self.assertTrue(foo['start'] > 0) + self.assertTrue('stop' not in foo, foo) + self.assertTrue('args' in foo, foo) + self.assertTrue(len(foo['args']), 2) + self.assertEquals(foo['args'][1], 'hello') + self.assertTrue('kwargs' in foo, foo) + self.assertTrue(len(foo['kwargs']), 1) + self.assertTrue('foo' in foo['kwargs']) + self.assertEquals(foo['kwargs']['foo'], 'bar') + + # callbacks['before'] = {} + # + # @pre_dispatch(TrackingTestCase.class_method) + # def test(**kwargs): + # foo.update(kwargs) + # + # self.assertTrue(hasattr(TrackingTestCase.class_method, '__wrapped__')) + # self.assertEquals(len(callbacks['before']), 1) + # + # TrackingTestCase.class_method() + # + # self.assertTrue('sender' in foo, foo) + # # best we can do + # self.assertEquals(foo['sender'].__name__, 'class_method') + # self.assertTrue('start' in foo, foo) + # self.assertTrue('stop' not in foo, foo) + # self.assertTrue('args' in foo, foo) + + def test_post_hook(self): + foo = {} + + @post_dispatch(module_func) + def test(**kwargs): + foo.update(kwargs) + + self.assertTrue(hasattr(module_func, '__wrapped__')) + self.assertEquals(len(callbacks['after']), 1) + + module_func('hi', foo='bar') + + self.assertTrue('sender' in foo, foo) + # best we can do + self.assertEquals(foo['sender'].__name__, 'module_func') + self.assertTrue('start' in foo, foo) + self.assertTrue(foo['start'] > 0) + self.assertTrue('stop' in foo, foo) + self.assertTrue(foo['stop'] > foo['start']) + self.assertTrue('args' in foo, foo) + self.assertTrue(len(foo['args']), 1) + self.assertEquals(foo['args'][0], 'hi') + self.assertTrue('kwargs' in foo, foo) + self.assertTrue(len(foo['kwargs']), 1) + self.assertTrue('foo' in foo['kwargs']) + self.assertEquals(foo['kwargs']['foo'], 'bar') + + callbacks['after'] = {} + + @post_dispatch(TrackingTestCase.class_func) + def test(**kwargs): + foo.update(kwargs) + + self.assertTrue(hasattr(TrackingTestCase.class_func, '__wrapped__')) + self.assertEquals(len(callbacks['after']), 1) + + self.class_func('hello', foo='bar') + + self.assertTrue('sender' in foo, foo) + # best we can do + self.assertEquals(foo['sender'].__name__, 'class_func') + self.assertTrue('start' in foo, foo) + self.assertTrue(foo['start'] > 0) + self.assertTrue('stop' in foo, foo) + self.assertTrue(foo['stop'] > foo['start']) + self.assertTrue('args' in foo, foo) + self.assertTrue(len(foo['args']), 2) + self.assertEquals(foo['args'][1], 'hello') + self.assertTrue('kwargs' in foo, foo) + self.assertTrue(len(foo['kwargs']), 1) + self.assertTrue('foo' in foo['kwargs']) + self.assertEquals(foo['kwargs']['foo'], 'bar') \ No newline at end of file diff --git a/tests/urls.py b/tests/urls.py new file mode 100644 index 0000000..d1cb07f --- /dev/null +++ b/tests/urls.py @@ -0,0 +1,14 @@ +""" +URLpatterns for the debug toolbar. + +These should not be loaded explicitly; the debug toolbar middleware will patch +this into the urlconf for the request. +""" +from django.conf.urls.defaults import * +from django.contrib import admin + +admin.autodiscover() + +urlpatterns = patterns('', + url(r'^execute_sql/$', 'tests.views.execute_sql'), +) diff --git a/tests/views.py b/tests/views.py new file mode 100644 index 0000000..f989dcd --- /dev/null +++ b/tests/views.py @@ -0,0 +1,7 @@ +from django.contrib.auth.models import User +from django.http import HttpResponse + +def execute_sql(request): + list(User.objects.all()) + + return HttpResponse() \ No newline at end of file -- cgit v1.2.3