Fixed #24982 -- Split staticfiles tests into multiple files (b35b43df) · Commits · Dom Sekotill / django

tests/staticfiles_tests/cases.py

0 → 100644

+136 −0

Original line number	Diff line number	Diff line
		# -- 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

0 → 100644

+32 −0

Original line number	Diff line number	Diff line
		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

0 → 100644

+118 −0

Original line number	Diff line number	Diff line
		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_management.py

0 → 100644

+341 −0

Original line number	Diff line number	Diff line
		from __future__ import unicode_literals

		import codecs
		import os
		import shutil
		import unittest

		from django.conf import settings
		from django.contrib.staticfiles import storage
		from django.contrib.staticfiles.management.commands import collectstatic
		from django.core.exceptions import ImproperlyConfigured
		from django.core.management import call_command
		from django.test import override_settings
		from django.utils import six
		from django.utils._os import symlinks_supported
		from django.utils.encoding import force_text
		from django.utils.functional import empty

		from .cases import CollectionTestCase, StaticFilesTestCase, TestDefaults
		from .settings import TEST_ROOT, TEST_SETTINGS
		from .storage import DummyStorage


		class TestNoFilesCreated(object):

		def test_no_files_created(self):
		"""
		Make sure no files were create in the destination directory.
		"""
		self.assertEqual(os.listdir(settings.STATIC_ROOT), [])


		class TestFindStatic(CollectionTestCase, TestDefaults):
		"""
		Test ``findstatic`` management command.
		"""
		def _get_file(self, filepath):
		out = six.StringIO()
		call_command('findstatic', filepath, all=False, verbosity=0, stdout=out)
		out.seek(0)
		lines = [l.strip() for l in out.readlines()]
		with codecs.open(force_text(lines[0].strip()), "r", "utf-8") as f:
		return f.read()

		def test_all_files(self):
		"""
		Test that findstatic returns all candidate files if run without --first and -v1.
		"""
		out = six.StringIO()
		call_command('findstatic', 'test/file.txt', verbosity=1, stdout=out)
		out.seek(0)
		lines = [l.strip() for l in out.readlines()]
		self.assertEqual(len(lines), 3) # three because there is also the "Found <file> here" line
		self.assertIn('project', force_text(lines[1]))
		self.assertIn('apps', force_text(lines[2]))

		def test_all_files_less_verbose(self):
		"""
		Test that findstatic returns all candidate files if run without --first and -v0.
		"""
		out = six.StringIO()
		call_command('findstatic', 'test/file.txt', verbosity=0, stdout=out)
		out.seek(0)
		lines = [l.strip() for l in out.readlines()]
		self.assertEqual(len(lines), 2)
		self.assertIn('project', force_text(lines[0]))
		self.assertIn('apps', force_text(lines[1]))

		def test_all_files_more_verbose(self):
		"""
		Test that findstatic returns all candidate files if run without --first and -v2.
		Also, test that findstatic returns the searched locations with -v2.
		"""
		out = six.StringIO()
		call_command('findstatic', 'test/file.txt', verbosity=2, stdout=out)
		out.seek(0)
		lines = [l.strip() for l in out.readlines()]
		self.assertIn('project', force_text(lines[1]))
		self.assertIn('apps', force_text(lines[2]))
		self.assertIn("Looking in the following locations:", force_text(lines[3]))
		searched_locations = ', '.join(force_text(x) for x in lines[4:])
		# AppDirectoriesFinder searched locations
		self.assertIn(os.path.join('staticfiles_tests', 'apps', 'test', 'static'), searched_locations)
		self.assertIn(os.path.join('staticfiles_tests', 'apps', 'no_label', 'static'), searched_locations)
		# FileSystemFinder searched locations
		self.assertIn(TEST_SETTINGS['STATICFILES_DIRS'][1][1], searched_locations)
		self.assertIn(TEST_SETTINGS['STATICFILES_DIRS'][0], searched_locations)
		# DefaultStorageFinder searched locations
		self.assertIn(
		os.path.join('staticfiles_tests', 'project', 'site_media', 'media'),
		searched_locations
		)


		class TestConfiguration(StaticFilesTestCase):
		def test_location_empty(self):
		err = six.StringIO()
		for root in ['', None]:
		with override_settings(STATIC_ROOT=root):
		with six.assertRaisesRegex(
		self, ImproperlyConfigured,
		'without having set the STATIC_ROOT setting to a filesystem path'):
		call_command('collectstatic', interactive=False, verbosity=0, stderr=err)

		def test_local_storage_detection_helper(self):
		staticfiles_storage = storage.staticfiles_storage
		try:
		storage.staticfiles_storage._wrapped = empty
		with self.settings(STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage'):
		command = collectstatic.Command()
		self.assertTrue(command.is_local_storage())

		storage.staticfiles_storage._wrapped = empty
		with self.settings(STATICFILES_STORAGE='staticfiles_tests.storage.DummyStorage'):
		command = collectstatic.Command()
		self.assertFalse(command.is_local_storage())

		collectstatic.staticfiles_storage = storage.FileSystemStorage()
		command = collectstatic.Command()
		self.assertTrue(command.is_local_storage())

		collectstatic.staticfiles_storage = DummyStorage()
		command = collectstatic.Command()
		self.assertFalse(command.is_local_storage())
		finally:
		staticfiles_storage._wrapped = empty
		collectstatic.staticfiles_storage = staticfiles_storage
		storage.staticfiles_storage = staticfiles_storage


		class TestCollection(CollectionTestCase, TestDefaults):
		"""
		Test ``collectstatic`` management command.
		"""
		def test_ignore(self):
		"""
		Test that -i patterns are ignored.
		"""
		self.assertFileNotFound('test/test.ignoreme')

		def test_common_ignore_patterns(self):
		"""
		Common ignore patterns (~, ., CVS) are ignored.
		"""
		self.assertFileNotFound('test/.hidden')
		self.assertFileNotFound('test/backup~')
		self.assertFileNotFound('test/CVS')


		class TestCollectionClear(CollectionTestCase):
		"""
		Test the ``--clear`` option of the ``collectstatic`` management command.
		"""
		def run_collectstatic(self, **kwargs):
		clear_filepath = os.path.join(settings.STATIC_ROOT, 'cleared.txt')
		with open(clear_filepath, 'w') as f:
		f.write('should be cleared')
		super(TestCollectionClear, self).run_collectstatic(clear=True)

		def test_cleared_not_found(self):
		self.assertFileNotFound('cleared.txt')

		def test_dir_not_exists(self, **kwargs):
		shutil.rmtree(six.text_type(settings.STATIC_ROOT))
		super(TestCollectionClear, self).run_collectstatic(clear=True)


		class TestCollectionExcludeNoDefaultIgnore(CollectionTestCase, TestDefaults):
		"""
		Test ``--exclude-dirs`` and ``--no-default-ignore`` options of the
		``collectstatic`` management command.
		"""
		def run_collectstatic(self):
		super(TestCollectionExcludeNoDefaultIgnore, self).run_collectstatic(
		use_default_ignore_patterns=False)

		def test_no_common_ignore_patterns(self):
		"""
		With --no-default-ignore, common ignore patterns (~, ., CVS)
		are not ignored.
		"""
		self.assertFileContains('test/.hidden', 'should be ignored')
		self.assertFileContains('test/backup~', 'should be ignored')
		self.assertFileContains('test/CVS', 'should be ignored')


		class TestCollectionDryRun(CollectionTestCase, TestNoFilesCreated):
		"""
		Test ``--dry-run`` option for ``collectstatic`` management command.
		"""
		def run_collectstatic(self):
		super(TestCollectionDryRun, self).run_collectstatic(dry_run=True)


		class TestCollectionFilesOverride(CollectionTestCase):
		"""
		Test overriding duplicated files by ``collectstatic`` management command.
		Check for proper handling of apps order in installed apps even if file modification
		dates are in different order:
		'staticfiles_tests.apps.test',
		'staticfiles_tests.apps.no_label',
		"""
		def setUp(self):
		self.orig_path = os.path.join(TEST_ROOT, 'apps', 'no_label', 'static', 'file2.txt')
		# get modification and access times for no_label/static/file2.txt
		self.orig_mtime = os.path.getmtime(self.orig_path)
		self.orig_atime = os.path.getatime(self.orig_path)

		# prepare duplicate of file2.txt from no_label app
		# this file will have modification time older than no_label/static/file2.txt
		# anyway it should be taken to STATIC_ROOT because 'test' app is before
		# 'no_label' app in installed apps
		self.testfile_path = os.path.join(TEST_ROOT, 'apps', 'test', 'static', 'file2.txt')
		with open(self.testfile_path, 'w+') as f:
		f.write('duplicate of file2.txt')
		os.utime(self.testfile_path, (self.orig_atime - 1, self.orig_mtime - 1))
		super(TestCollectionFilesOverride, self).setUp()

		def tearDown(self):
		if os.path.exists(self.testfile_path):
		os.unlink(self.testfile_path)
		# set back original modification time
		os.utime(self.orig_path, (self.orig_atime, self.orig_mtime))
		super(TestCollectionFilesOverride, self).tearDown()

		def test_ordering_override(self):
		"""
		Test if collectstatic takes files in proper order
		"""
		self.assertFileContains('file2.txt', 'duplicate of file2.txt')

		# run collectstatic again
		self.run_collectstatic()

		self.assertFileContains('file2.txt', 'duplicate of file2.txt')

		# and now change modification time of no_label/static/file2.txt
		# test app is first in installed apps so file2.txt should remain unmodified
		mtime = os.path.getmtime(self.testfile_path)
		atime = os.path.getatime(self.testfile_path)
		os.utime(self.orig_path, (mtime + 1, atime + 1))

		# run collectstatic again
		self.run_collectstatic()

		self.assertFileContains('file2.txt', 'duplicate of file2.txt')


		# The collectstatic test suite already has conflicting files since both
		# project/test/file.txt and apps/test/static/test/file.txt are collected. To
		# properly test for the warning not happening unless we tell it to explicitly,
		# we only include static files from the default finders.
		@override_settings(STATICFILES_DIRS=[])
		class TestCollectionOverwriteWarning(CollectionTestCase):
		"""
		Test warning in ``collectstatic`` output when a file is skipped because a
		previous file was already written to the same path.
		"""
		# If this string is in the collectstatic output, it means the warning we're
		# looking for was emitted.
		warning_string = 'Found another file'

		def _collectstatic_output(self, **kwargs):
		"""
		Run collectstatic, and capture and return the output. We want to run
		the command at highest verbosity, which is why we can't
		just call e.g. BaseCollectionTestCase.run_collectstatic()
		"""
		out = six.StringIO()
		call_command('collectstatic', interactive=False, verbosity=3, stdout=out, **kwargs)
		out.seek(0)
		return out.read()

		def test_no_warning(self):
		"""
		There isn't a warning if there isn't a duplicate destination.
		"""
		output = self._collectstatic_output(clear=True)
		self.assertNotIn(self.warning_string, force_text(output))

		def test_warning(self):
		"""
		There is a warning when there are duplicate destinations.
		"""
		# Create new file in the no_label app that also exists in the test app.
		test_dir = os.path.join(TEST_ROOT, 'apps', 'no_label', 'static', 'test')
		if not os.path.exists(test_dir):
		os.mkdir(test_dir)

		try:
		duplicate_path = os.path.join(test_dir, 'file.txt')
		with open(duplicate_path, 'w+') as f:
		f.write('duplicate of file.txt')
		output = self._collectstatic_output(clear=True)
		self.assertIn(self.warning_string, force_text(output))
		finally:
		if os.path.exists(duplicate_path):
		os.unlink(duplicate_path)

		if os.path.exists(test_dir):
		os.rmdir(test_dir)

		# Make sure the warning went away again.
		output = self._collectstatic_output(clear=True)
		self.assertNotIn(self.warning_string, force_text(output))


		@override_settings(STATICFILES_STORAGE='staticfiles_tests.storage.DummyStorage')
		class TestCollectionNonLocalStorage(CollectionTestCase, TestNoFilesCreated):
		"""
		Tests for #15035
		"""
		pass


		@unittest.skipUnless(symlinks_supported(), "Must be able to symlink to run this test.")
		class TestCollectionLinks(CollectionTestCase, TestDefaults):
		"""
		Test ``--link`` option for ``collectstatic`` management command.

		Note that by inheriting ``TestDefaults`` we repeat all
		the standard file resolving tests here, to make sure using
		``--link`` does not change the file-selection semantics.
		"""
		def run_collectstatic(self):
		super(TestCollectionLinks, self).run_collectstatic(link=True)

		def test_links_created(self):
		"""
		With ``--link``, symbolic links are created.
		"""
		self.assertTrue(os.path.islink(os.path.join(settings.STATIC_ROOT, 'test.txt')))

		def test_broken_symlink(self):
		"""
		Test broken symlink gets deleted.
		"""
		path = os.path.join(settings.STATIC_ROOT, 'test.txt')
		os.unlink(path)
		self.run_collectstatic()
		self.assertTrue(os.path.islink(path))

tests/staticfiles_tests/tests.py→tests/staticfiles_tests/test_storage.py

+416 −0

File changed and moved.

Preview size limit exceeded, changes collapsed.