Fixed #24982 -- Split staticfiles tests into multiple files

tests/staticfiles_tests/cases.py

+# -*- encoding: utf-8 -*-
+from __future__ import unicode_literals
+
+import codecs
+import os
+import shutil
+import tempfile
+
+from django.conf import settings
+from django.core.management import call_command
+from django.template import Context, Template
+from django.test import SimpleTestCase, override_settings
+from django.utils import six
+from django.utils.encoding import force_text
+
+from .settings import TEST_SETTINGS
+
+
+class BaseStaticFilesTestCase(object):
+    """
+    Test case with a couple utility assertions.
+    """
+
+    def assertFileContains(self, filepath, text):
+        self.assertIn(
+            text,
+            self._get_file(force_text(filepath)),
+            "'%s' not in '%s'" % (text, filepath),
+        )
+
+    def assertFileNotFound(self, filepath):
+        self.assertRaises(IOError, self._get_file, filepath)
+
+    def render_template(self, template, **kwargs):
+        if isinstance(template, six.string_types):
+            template = Template(template)
+        return template.render(Context(kwargs)).strip()
+
+    def static_template_snippet(self, path, asvar=False):
+        if asvar:
+            return "{%% load static from staticfiles %%}{%% static '%s' as var %%}{{ var }}" % path
+        return "{%% load static from staticfiles %%}{%% static '%s' %%}" % path
+
+    def assertStaticRenders(self, path, result, asvar=False, **kwargs):
+        template = self.static_template_snippet(path, asvar)
+        self.assertEqual(self.render_template(template, **kwargs), result)
+
+    def assertStaticRaises(self, exc, path, result, asvar=False, **kwargs):
+        self.assertRaises(exc, self.assertStaticRenders, path, result, **kwargs)
+
+
+@override_settings(**TEST_SETTINGS)
+class StaticFilesTestCase(BaseStaticFilesTestCase, SimpleTestCase):
+    pass
+
+
+class BaseCollectionTestCase(BaseStaticFilesTestCase):
+    """
+    Tests shared by all file finding features (collectstatic,
+    findstatic, and static serve view).
+
+    This relies on the asserts defined in BaseStaticFilesTestCase, but
+    is separated because some test cases need those asserts without
+    all these tests.
+    """
+    def setUp(self):
+        super(BaseCollectionTestCase, self).setUp()
+        temp_dir = tempfile.mkdtemp()
+        # Override the STATIC_ROOT for all tests from setUp to tearDown
+        # rather than as a context manager
+        self.patched_settings = self.settings(STATIC_ROOT=temp_dir)
+        self.patched_settings.enable()
+        self.run_collectstatic()
+        # Same comment as in runtests.teardown.
+        self.addCleanup(shutil.rmtree, six.text_type(temp_dir))
+
+    def tearDown(self):
+        self.patched_settings.disable()
+        super(BaseCollectionTestCase, self).tearDown()
+
+    def run_collectstatic(self, **kwargs):
+        call_command('collectstatic', interactive=False, verbosity=0,
+                     ignore_patterns=['*.ignoreme'], **kwargs)
+
+    def _get_file(self, filepath):
+        assert filepath, 'filepath is empty.'
+        filepath = os.path.join(settings.STATIC_ROOT, filepath)
+        with codecs.open(filepath, "r", "utf-8") as f:
+            return f.read()
+
+
+class CollectionTestCase(BaseCollectionTestCase, StaticFilesTestCase):
+    pass
+
+
+class TestDefaults(object):
+    """
+    A few standard test cases.
+    """
+    def test_staticfiles_dirs(self):
+        """
+        Can find a file in a STATICFILES_DIRS directory.
+        """
+        self.assertFileContains('test.txt', 'Can we find')
+        self.assertFileContains(os.path.join('prefix', 'test.txt'), 'Prefix')
+
+    def test_staticfiles_dirs_subdir(self):
+        """
+        Can find a file in a subdirectory of a STATICFILES_DIRS
+        directory.
+        """
+        self.assertFileContains('subdir/test.txt', 'Can we find')
+
+    def test_staticfiles_dirs_priority(self):
+        """
+        File in STATICFILES_DIRS has priority over file in app.
+        """
+        self.assertFileContains('test/file.txt', 'STATICFILES_DIRS')
+
+    def test_app_files(self):
+        """
+        Can find a file in an app static/ directory.
+        """
+        self.assertFileContains('test/file1.txt', 'file1 in the app dir')
+
+    def test_nonascii_filenames(self):
+        """
+        Can find a file with non-ASCII character in an app static/ directory.
+        """
+        self.assertFileContains('test/⊗.txt', '⊗ in the app dir')
+
+    def test_camelcase_filenames(self):
+        """
+        Can find a file with capital letters.
+        """
+        self.assertFileContains('test/camelCase.txt', 'camelCase')

tests/staticfiles_tests/settings.py

+from __future__ import unicode_literals
+
+import os.path
+
+from django.utils._os import upath
+
+TEST_ROOT = os.path.dirname(upath(__file__))
+
+TESTFILES_PATH = os.path.join(TEST_ROOT, 'apps', 'test', 'static', 'test')
+
+TEST_SETTINGS = {
+    'DEBUG': True,
+    'MEDIA_URL': '/media/',
+    'STATIC_URL': '/static/',
+    'MEDIA_ROOT': os.path.join(TEST_ROOT, 'project', 'site_media', 'media'),
+    'STATIC_ROOT': os.path.join(TEST_ROOT, 'project', 'site_media', 'static'),
+    'STATICFILES_DIRS': [
+        os.path.join(TEST_ROOT, 'project', 'documents'),
+        ('prefix', os.path.join(TEST_ROOT, 'project', 'prefixed')),
+    ],
+    'STATICFILES_FINDERS': [
+        'django.contrib.staticfiles.finders.FileSystemFinder',
+        'django.contrib.staticfiles.finders.AppDirectoriesFinder',
+        'django.contrib.staticfiles.finders.DefaultStorageFinder',
+    ],
+    'INSTALLED_APPS': [
+        'django.contrib.staticfiles',
+        'staticfiles_tests',
+        'staticfiles_tests.apps.test',
+        'staticfiles_tests.apps.no_label',
+    ],
+}

tests/staticfiles_tests/test_finders.py

+from __future__ import unicode_literals
+
+import os
+
+from django.conf import settings
+from django.contrib.staticfiles import finders, storage
+from django.core.exceptions import ImproperlyConfigured
+from django.test import SimpleTestCase, override_settings
+
+from .cases import StaticFilesTestCase
+from .settings import TEST_ROOT
+
+
+class FinderTestCase(object):
+    """
+    Base finder test mixin.
+
+    On Windows, sometimes the case of the path we ask the finders for and the
+    path(s) they find can differ. Compare them using os.path.normcase() to
+    avoid false negatives.
+    """
+    def test_find_first(self):
+        src, dst = self.find_first
+        found = self.finder.find(src)
+        self.assertEqual(os.path.normcase(found), os.path.normcase(dst))
+
+    def test_find_all(self):
+        src, dst = self.find_all
+        found = self.finder.find(src, all=True)
+        found = [os.path.normcase(f) for f in found]
+        dst = [os.path.normcase(d) for d in dst]
+        self.assertEqual(found, dst)
+
+
+class TestFileSystemFinder(StaticFilesTestCase, FinderTestCase):
+    """
+    Test FileSystemFinder.
+    """
+    def setUp(self):
+        super(TestFileSystemFinder, self).setUp()
+        self.finder = finders.FileSystemFinder()
+        test_file_path = os.path.join(TEST_ROOT, 'project', 'documents', 'test', 'file.txt')
+        self.find_first = (os.path.join('test', 'file.txt'), test_file_path)
+        self.find_all = (os.path.join('test', 'file.txt'), [test_file_path])
+
+
+class TestAppDirectoriesFinder(StaticFilesTestCase, FinderTestCase):
+    """
+    Test AppDirectoriesFinder.
+    """
+    def setUp(self):
+        super(TestAppDirectoriesFinder, self).setUp()
+        self.finder = finders.AppDirectoriesFinder()
+        test_file_path = os.path.join(TEST_ROOT, 'apps', 'test', 'static', 'test', 'file1.txt')
+        self.find_first = (os.path.join('test', 'file1.txt'), test_file_path)
+        self.find_all = (os.path.join('test', 'file1.txt'), [test_file_path])
+
+
+class TestDefaultStorageFinder(StaticFilesTestCase, FinderTestCase):
+    """
+    Test DefaultStorageFinder.
+    """
+    def setUp(self):
+        super(TestDefaultStorageFinder, self).setUp()
+        self.finder = finders.DefaultStorageFinder(
+            storage=storage.StaticFilesStorage(location=settings.MEDIA_ROOT))
+        test_file_path = os.path.join(settings.MEDIA_ROOT, 'media-file.txt')
+        self.find_first = ('media-file.txt', test_file_path)
+        self.find_all = ('media-file.txt', [test_file_path])
+
+
+@override_settings(
+    STATICFILES_FINDERS=['django.contrib.staticfiles.finders.FileSystemFinder'],
+    STATICFILES_DIRS=[os.path.join(TEST_ROOT, 'project', 'documents')],
+)
+class TestMiscFinder(SimpleTestCase):
+    """
+    A few misc finder tests.
+    """
+    def test_get_finder(self):
+        self.assertIsInstance(finders.get_finder(
+            'django.contrib.staticfiles.finders.FileSystemFinder'),
+            finders.FileSystemFinder)
+
+    def test_get_finder_bad_classname(self):
+        with self.assertRaises(ImportError):
+            finders.get_finder('django.contrib.staticfiles.finders.FooBarFinder')
+
+    def test_get_finder_bad_module(self):
+        with self.assertRaises(ImportError):
+            finders.get_finder('foo.bar.FooBarFinder')
+
+    def test_cache(self):
+        finders.get_finder.cache_clear()
+        for n in range(10):
+            finders.get_finder('django.contrib.staticfiles.finders.FileSystemFinder')
+        cache_info = finders.get_finder.cache_info()
+        self.assertEqual(cache_info.hits, 9)
+        self.assertEqual(cache_info.currsize, 1)
+
+    def test_searched_locations(self):
+        finders.find('spam')
+        self.assertEqual(
+            finders.searched_locations,
+            [os.path.join(TEST_ROOT, 'project', 'documents')]
+        )
+
+    @override_settings(STATICFILES_DIRS='a string')
+    def test_non_tuple_raises_exception(self):
+        """
+        We can't determine if STATICFILES_DIRS is set correctly just by
+        looking at the type, but we can determine if it's definitely wrong.
+        """
+        self.assertRaises(ImproperlyConfigured, finders.FileSystemFinder)
+
+    @override_settings(MEDIA_ROOT='')
+    def test_location_empty(self):
+        self.assertRaises(ImproperlyConfigured, finders.DefaultStorageFinder)

tests/staticfiles_tests/test_templatetags.py

+from __future__ import unicode_literals
+
+from .cases import StaticFilesTestCase
+
+
+class TestTemplateTag(StaticFilesTestCase):
+
+    def test_template_tag(self):
+        self.assertStaticRenders("does/not/exist.png", "/static/does/not/exist.png")
+        self.assertStaticRenders("testfile.txt", "/static/testfile.txt")

tests/staticfiles_tests/test_views.py

+from __future__ import unicode_literals
+
+import posixpath
+
+from django.conf import settings
+from django.test import override_settings
+
+from .cases import StaticFilesTestCase, TestDefaults
+
+
+@override_settings(ROOT_URLCONF='staticfiles_tests.urls.default')
+class TestServeStatic(StaticFilesTestCase):
+    """
+    Test static asset serving view.
+    """
+    def _response(self, filepath):
+        return self.client.get(
+            posixpath.join(settings.STATIC_URL, filepath))
+
+    def assertFileContains(self, filepath, text):
+        self.assertContains(self._response(filepath), text)
+
+    def assertFileNotFound(self, filepath):
+        self.assertEqual(self._response(filepath).status_code, 404)
+
+
+@override_settings(DEBUG=False)
+class TestServeDisabled(TestServeStatic):
+    """
+    Test serving static files disabled when DEBUG is False.
+    """
+    def test_disabled_serving(self):
+        self.assertFileNotFound('test.txt')
+
+
+class TestServeStaticWithDefaultURL(TestServeStatic, TestDefaults):
+    """
+    Test static asset serving view with manually configured URLconf.
+    """
+
+
+@override_settings(ROOT_URLCONF='staticfiles_tests.urls.helper')
+class TestServeStaticWithURLHelper(TestServeStatic, TestDefaults):
+    """
+    Test static asset serving view with staticfiles_urlpatterns helper.
+    """