Split tests across several modules.

Fix #426.

Author: aaugustin

tests/base.py

@@ -0,0 +1,26 @@
+from __future__ import unicode_literals
+
+import threading
+
+from django.http import HttpResponse
+from django.test import TestCase, RequestFactory
+
+from debug_toolbar.middleware import DebugToolbarMiddleware
+from debug_toolbar.toolbar.loader import DebugToolbar
+
+rf = RequestFactory()
+
+
+class BaseTestCase(TestCase):
+
+    def setUp(self):
+        request = rf.get('/')
+        response = HttpResponse()
+        toolbar = DebugToolbar(request)
+
+        DebugToolbarMiddleware.debug_toolbars[threading.current_thread().ident] = toolbar
+
+        self.request = request
+        self.response = response
+        self.toolbar = toolbar
+        self.toolbar.stats = {}

tests/commands/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import unicode_literals
+
+import sys
+
+from django.contrib.auth.models import User
+from django.core import management
+from django.db.backends import util
+from django.test import TestCase
+from django.test.utils import override_settings
+from django.utils import six
+
+
+@override_settings(DEBUG=True)
+class DebugSQLShellTestCase(TestCase):
+
+    def setUp(self):
+        self.original_cursor_wrapper = util.CursorDebugWrapper
+        # Since debugsqlshell monkey-patches django.db.backends.util, we can
+        # test it simply by loading it, without executing it. But we have to
+        # undo the monkey-patch on exit.
+        command_name = 'debugsqlshell'
+        app_name = management.get_commands()[command_name]
+        management.load_command_class(app_name, command_name)
+
+    def tearDown(self):
+        util.CursorDebugWrapper = self.original_cursor_wrapper
+
+    def test_command(self):
+        original_stdout, sys.stdout = sys.stdout, six.StringIO()
+        try:
+            User.objects.count()
+            self.assertIn("SELECT COUNT(*)", sys.stdout.getvalue())
+        finally:
+            sys.stdout = original_stdout

tests/commands/test_debugsqlshell.py

@@ -0,0 +1,53 @@
+from __future__ import unicode_literals
+
+import logging
+
+from debug_toolbar.panels.logger import (
+    LoggingPanel, MESSAGE_IF_STRING_REPRESENTATION_INVALID)
+
+from ..base import BaseTestCase
+
+
+class LoggingPanelTestCase(BaseTestCase):
+
+    def test_happy_case(self):
+        logger = logging.getLogger(__name__)
+        logger.info('Nothing to see here, move along!')
+
+        logging_panel = self.toolbar.get_panel(LoggingPanel)
+        logging_panel.process_response(None, None)
+        records = logging_panel.get_stats()['records']
+
+        self.assertEqual(1, len(records))
+        self.assertEqual('Nothing to see here, move along!',
+                         records[0]['message'])
+
+    def test_formatting(self):
+        logger = logging.getLogger(__name__)
+        logger.info('There are %d %s', 5, 'apples')
+
+        logging_panel = self.toolbar.get_panel(LoggingPanel)
+        logging_panel.process_response(None, None)
+        records = logging_panel.get_stats()['records']
+
+        self.assertEqual(1, len(records))
+        self.assertEqual('There are 5 apples',
+                         records[0]['message'])
+
+    def test_failing_formatting(self):
+        class BadClass(object):
+            def __str__(self):
+                raise Exception('Please not stringify me!')
+
+        logger = logging.getLogger(__name__)
+
+        # should not raise exception, but fail silently
+        logger.debug('This class is misbehaving: %s', BadClass())
+
+        logging_panel = self.toolbar.get_panel(LoggingPanel)
+        logging_panel.process_response(None, None)
+        records = logging_panel.get_stats()['records']
+
+        self.assertEqual(1, len(records))
+        self.assertEqual(MESSAGE_IF_STRING_REPRESENTATION_INVALID,
+                         records[0]['message'])

tests/panels/__init__.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+from __future__ import unicode_literals
+
+from django.contrib.auth.models import User
+from django.db import connection
+from django.db.utils import DatabaseError
+from django.utils import unittest
+
+from debug_toolbar.panels.sql import SQLDebugPanel
+
+from ..base import BaseTestCase
+
+
+class SQLPanelTestCase(BaseTestCase):
+
+    def test_recording(self):
+        panel = self.toolbar.get_panel(SQLDebugPanel)
+        self.assertEqual(len(panel._queries), 0)
+
+        list(User.objects.all())
+
+        # ensure query was logged
+        self.assertEqual(len(panel._queries), 1)
+        query = panel._queries[0]
+        self.assertEqual(query[0], 'default')
+        self.assertTrue('sql' in query[1])
+        self.assertTrue('duration' in query[1])
+        self.assertTrue('stacktrace' in query[1])
+
+        # ensure the stacktrace is populated
+        self.assertTrue(len(query[1]['stacktrace']) > 0)
+
+    def test_non_ascii_query(self):
+        panel = self.toolbar.get_panel(SQLDebugPanel)
+        self.assertEqual(len(panel._queries), 0)
+
+        # non-ASCII query
+        list(User.objects.extra(where=["username = 'café'"]))
+        self.assertEqual(len(panel._queries), 1)
+
+        # non-ASCII parameters
+        list(User.objects.filter(username='café'))
+        self.assertEqual(len(panel._queries), 2)
+
+    @unittest.skipUnless(connection.vendor == 'postgresql',
+                         'Test valid only on PostgreSQL')
+    def test_erroneous_query(self):
+        """
+        Test that an error in the query isn't swallowed by the middleware.
+        """
+        try:
+            connection.cursor().execute("erroneous query")
+        except DatabaseError as e:
+            self.assertTrue('erroneous query' in str(e))
+
+    def test_disable_stacktraces(self):
+        panel = self.toolbar.get_panel(SQLDebugPanel)
+        self.assertEqual(len(panel._queries), 0)
+
+        with self.settings(DEBUG_TOOLBAR_CONFIG={'ENABLE_STACKTRACES': False}):
+            list(User.objects.all())
+
+        # ensure query was logged
+        self.assertEqual(len(panel._queries), 1)
+        query = panel._queries[0]
+        self.assertEqual(query[0], 'default')
+        self.assertTrue('sql' in query[1])
+        self.assertTrue('duration' in query[1])
+        self.assertTrue('stacktrace' in query[1])
+
+        # ensure the stacktrace is empty
+        self.assertEqual([], query[1]['stacktrace'])

tests/panels/test_logger.py

@@ -0,0 +1,31 @@
+from __future__ import unicode_literals
+
+import django
+from django.contrib.auth.models import User
+from django.template import Template, Context
+
+from debug_toolbar.panels.template import TemplateDebugPanel
+from debug_toolbar.panels.sql import SQLDebugPanel
+
+from ..base import BaseTestCase
+
+
+class TemplateDebugPanelTestCase(BaseTestCase):
+
+    def test_queryset_hook(self):
+        template_panel = self.toolbar.get_panel(TemplateDebugPanel)
+        sql_panel = self.toolbar.get_panel(SQLDebugPanel)
+        t = Template("No context variables here!")
+        c = Context({
+            'queryset': User.objects.all(),
+            'deep_queryset': {
+                'queryset': User.objects.all(),
+            }
+        })
+        t.render(c)
+        # ensure the query was NOT logged
+        self.assertEqual(len(sql_panel._queries), 0)
+        base_ctx_idx = 1 if django.VERSION[:2] >= (1, 5) else 0
+        ctx = template_panel.templates[0]['context'][base_ctx_idx]
+        self.assertIn('<<queryset of auth.User>>', ctx)
+        self.assertIn('<<triggers database query>>', ctx)