tests/test_loader.py - platform/external/python/jinja - Git at Google

 import importlib.abc
 import importlib.machinery
 import importlib.util
 import os
 import platform
 import shutil
 import sys
 import tempfile
 import time
 import weakref

 import pytest

 from jinja2 import Environment
 from jinja2 import loaders
 from jinja2 import PackageLoader
 from jinja2.exceptions import TemplateNotFound
 from jinja2.loaders import split_template_path


 class TestLoaders:
     def test_dict_loader(self, dict_loader):
         env = Environment(loader=dict_loader)
         tmpl = env.get_template("justdict.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")

     def test_package_loader(self, package_loader):
         env = Environment(loader=package_loader)
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")

     def test_filesystem_loader_overlapping_names(self, filesystem_loader):
         res = os.path.dirname(filesystem_loader.searchpath[0])
         t2_dir = os.path.join(res, "templates2")
         # Make "foo" show up before "foo/test.html".
         filesystem_loader.searchpath.insert(0, t2_dir)
         e = Environment(loader=filesystem_loader)
         e.get_template("foo")
         # This would raise NotADirectoryError if "t2/foo" wasn't skipped.
         e.get_template("foo/test.html")

     def test_choice_loader(self, choice_loader):
         env = Environment(loader=choice_loader)
         tmpl = env.get_template("justdict.html")
         assert tmpl.render().strip() == "FOO"
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")

     def test_function_loader(self, function_loader):
         env = Environment(loader=function_loader)
         tmpl = env.get_template("justfunction.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")

     def test_prefix_loader(self, prefix_loader):
         env = Environment(loader=prefix_loader)
         tmpl = env.get_template("a/test.html")
         assert tmpl.render().strip() == "BAR"
         tmpl = env.get_template("b/justdict.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing")

     def test_caching(self):
         changed = False

         class TestLoader(loaders.BaseLoader):
             def get_source(self, environment, template):
                 return "foo", None, lambda: not changed

         env = Environment(loader=TestLoader(), cache_size=-1)
         tmpl = env.get_template("template")
         assert tmpl is env.get_template("template")
         changed = True
         assert tmpl is not env.get_template("template")
         changed = False

     def test_no_cache(self):
         mapping = {"foo": "one"}
         env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
         assert env.get_template("foo") is not env.get_template("foo")

     def test_limited_size_cache(self):
         mapping = {"one": "foo", "two": "bar", "three": "baz"}
         loader = loaders.DictLoader(mapping)
         env = Environment(loader=loader, cache_size=2)
         t1 = env.get_template("one")
         t2 = env.get_template("two")
         assert t2 is env.get_template("two")
         assert t1 is env.get_template("one")
         env.get_template("three")
         loader_ref = weakref.ref(loader)
         assert (loader_ref, "one") in env.cache
         assert (loader_ref, "two") not in env.cache
         assert (loader_ref, "three") in env.cache

     def test_cache_loader_change(self):
         loader1 = loaders.DictLoader({"foo": "one"})
         loader2 = loaders.DictLoader({"foo": "two"})
         env = Environment(loader=loader1, cache_size=2)
         assert env.get_template("foo").render() == "one"
         env.loader = loader2
         assert env.get_template("foo").render() == "two"

     def test_dict_loader_cache_invalidates(self):
         mapping = {"foo": "one"}
         env = Environment(loader=loaders.DictLoader(mapping))
         assert env.get_template("foo").render() == "one"
         mapping["foo"] = "two"
         assert env.get_template("foo").render() == "two"

     def test_split_template_path(self):
         assert split_template_path("foo/bar") == ["foo", "bar"]
         assert split_template_path("./foo/bar") == ["foo", "bar"]
         pytest.raises(TemplateNotFound, split_template_path, "../foo")


 class TestFileSystemLoader:
     searchpath = os.path.join(
         os.path.dirname(os.path.abspath(__file__)), "res", "templates"
     )

     @staticmethod
     def _test_common(env):
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         tmpl = env.get_template("foo/test.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")

     def test_searchpath_as_str(self):
         filesystem_loader = loaders.FileSystemLoader(self.searchpath)

         env = Environment(loader=filesystem_loader)
         self._test_common(env)

     def test_searchpath_as_pathlib(self):
         import pathlib

         searchpath = pathlib.Path(self.searchpath)
         filesystem_loader = loaders.FileSystemLoader(searchpath)
         env = Environment(loader=filesystem_loader)
         self._test_common(env)

     def test_searchpath_as_list_including_pathlib(self):
         import pathlib

         searchpath = pathlib.Path(self.searchpath)
         filesystem_loader = loaders.FileSystemLoader(["/tmp/templates", searchpath])
         env = Environment(loader=filesystem_loader)
         self._test_common(env)

     def test_caches_template_based_on_mtime(self):
         filesystem_loader = loaders.FileSystemLoader(self.searchpath)

         env = Environment(loader=filesystem_loader)
         tmpl1 = env.get_template("test.html")
         tmpl2 = env.get_template("test.html")
         assert tmpl1 is tmpl2

         os.utime(os.path.join(self.searchpath, "test.html"), (time.time(), time.time()))
         tmpl3 = env.get_template("test.html")
         assert tmpl1 is not tmpl3

     @pytest.mark.parametrize(
         ("encoding", "expect"),
         [
             ("utf-8", "文字化け"),
             ("iso-8859-1", "æ\x96\x87\xe5\xad\x97\xe5\x8c\x96\xe3\x81\x91"),
         ],
     )
     def test_uses_specified_encoding(self, encoding, expect):
         loader = loaders.FileSystemLoader(self.searchpath, encoding=encoding)
         e = Environment(loader=loader)
         t = e.get_template("mojibake.txt")
         assert t.render() == expect


 class TestModuleLoader:
     archive = None

     def compile_down(self, prefix_loader, zip="deflated"):
         log = []
         self.reg_env = Environment(loader=prefix_loader)
         if zip is not None:
             fd, self.archive = tempfile.mkstemp(suffix=".zip")
             os.close(fd)
         else:
             self.archive = tempfile.mkdtemp()
         self.reg_env.compile_templates(self.archive, zip=zip, log_function=log.append)
         self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
         return "".join(log)

     def teardown(self):
         if hasattr(self, "mod_env"):
             if os.path.isfile(self.archive):
                 os.remove(self.archive)
             else:
                 shutil.rmtree(self.archive)
             self.archive = None

     def test_log(self, prefix_loader):
         log = self.compile_down(prefix_loader)
         assert (
             'Compiled "a/foo/test.html" as '
             "tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a" in log
         )
         assert "Finished compiling templates" in log
         assert (
             'Could not compile "a/syntaxerror.html": '
             "Encountered unknown tag 'endif'" in log
         )

     def _test_common(self):
         tmpl1 = self.reg_env.get_template("a/test.html")
         tmpl2 = self.mod_env.get_template("a/test.html")
         assert tmpl1.render() == tmpl2.render()

         tmpl1 = self.reg_env.get_template("b/justdict.html")
         tmpl2 = self.mod_env.get_template("b/justdict.html")
         assert tmpl1.render() == tmpl2.render()

     def test_deflated_zip_compile(self, prefix_loader):
         self.compile_down(prefix_loader, zip="deflated")
         self._test_common()

     def test_stored_zip_compile(self, prefix_loader):
         self.compile_down(prefix_loader, zip="stored")
         self._test_common()

     def test_filesystem_compile(self, prefix_loader):
         self.compile_down(prefix_loader, zip=None)
         self._test_common()

     def test_weak_references(self, prefix_loader):
         self.compile_down(prefix_loader)
         self.mod_env.get_template("a/test.html")
         key = loaders.ModuleLoader.get_template_key("a/test.html")
         name = self.mod_env.loader.module.__name__

         assert hasattr(self.mod_env.loader.module, key)
         assert name in sys.modules

         # unset all, ensure the module is gone from sys.modules
         self.mod_env = None

         try:
             import gc

             gc.collect()
         except BaseException:
             pass

         assert name not in sys.modules

     def test_choice_loader(self, prefix_loader):
         self.compile_down(prefix_loader)
         self.mod_env.loader = loaders.ChoiceLoader(
             [self.mod_env.loader, loaders.DictLoader({"DICT_SOURCE": "DICT_TEMPLATE"})]
         )
         tmpl1 = self.mod_env.get_template("a/test.html")
         assert tmpl1.render() == "BAR"
         tmpl2 = self.mod_env.get_template("DICT_SOURCE")
         assert tmpl2.render() == "DICT_TEMPLATE"

     def test_prefix_loader(self, prefix_loader):
         self.compile_down(prefix_loader)
         self.mod_env.loader = loaders.PrefixLoader(
             {
                 "MOD": self.mod_env.loader,
                 "DICT": loaders.DictLoader({"test.html": "DICT_TEMPLATE"}),
             }
         )
         tmpl1 = self.mod_env.get_template("MOD/a/test.html")
         assert tmpl1.render() == "BAR"
         tmpl2 = self.mod_env.get_template("DICT/test.html")
         assert tmpl2.render() == "DICT_TEMPLATE"

     def test_path_as_pathlib(self, prefix_loader):
         self.compile_down(prefix_loader)

         mod_path = self.mod_env.loader.module.__path__[0]

         import pathlib

         mod_loader = loaders.ModuleLoader(pathlib.Path(mod_path))
         self.mod_env = Environment(loader=mod_loader)

         self._test_common()

     def test_supports_pathlib_in_list_of_paths(self, prefix_loader):
         self.compile_down(prefix_loader)

         mod_path = self.mod_env.loader.module.__path__[0]

         import pathlib

         mod_loader = loaders.ModuleLoader([pathlib.Path(mod_path), "/tmp/templates"])
         self.mod_env = Environment(loader=mod_loader)

         self._test_common()


 @pytest.fixture()
 def package_dir_loader(monkeypatch):
     monkeypatch.syspath_prepend(os.path.dirname(__file__))
     return PackageLoader("res")


 @pytest.mark.parametrize(
     ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
 )
 def test_package_dir_source(package_dir_loader, template, expect):
     source, name, up_to_date = package_dir_loader.get_source(None, template)
     assert source.rstrip() == expect
     assert name.endswith(os.path.join(*split_template_path(template)))
     assert up_to_date()


 def test_package_dir_list(package_dir_loader):
     templates = package_dir_loader.list_templates()
     assert "foo/test.html" in templates
     assert "test.html" in templates


 @pytest.fixture()
 def package_zip_loader(monkeypatch):
     monkeypatch.syspath_prepend(
         os.path.join(os.path.dirname(__file__), "res", "package.zip")
     )
     return PackageLoader("t_pack")


 @pytest.mark.parametrize(
     ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
 )
 def test_package_zip_source(package_zip_loader, template, expect):
     source, name, up_to_date = package_zip_loader.get_source(None, template)
     assert source.rstrip() == expect
     assert name.endswith(os.path.join(*split_template_path(template)))
     assert up_to_date is None


 @pytest.mark.xfail(
     platform.python_implementation() == "PyPy",
     reason="PyPy's zipimporter doesn't have a '_files' attribute.",
     raises=TypeError,
 )
 def test_package_zip_list(package_zip_loader):
     assert package_zip_loader.list_templates() == ["foo/test.html", "test.html"]


 def test_pep_451_import_hook():
     class ImportHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
         def find_spec(self, name, path=None, target=None):
             if name != "res":
                 return None

             spec = importlib.machinery.PathFinder.find_spec(name)
             return importlib.util.spec_from_file_location(
                 name,
                 spec.origin,
                 loader=self,
                 submodule_search_locations=spec.submodule_search_locations,
             )

         def create_module(self, spec):
             return None  # default behaviour is fine

         def exec_module(self, module):
             return None  # we need this to satisfy the interface, it's wrong

     # ensure we restore `sys.meta_path` after putting in our loader
     before = sys.meta_path[:]

     try:
         sys.meta_path.insert(0, ImportHook())
         package_loader = PackageLoader("res")
         assert "test.html" in package_loader.list_templates()
     finally:
         sys.meta_path[:] = before
	import importlib.abc
	import importlib.machinery
	import importlib.util
	import os
	import platform
	import shutil
	import sys
	import tempfile
	import time
	import weakref

	import pytest

	from jinja2 import Environment
	from jinja2 import loaders
	from jinja2 import PackageLoader
	from jinja2.exceptions import TemplateNotFound
	from jinja2.loaders import split_template_path


	class TestLoaders:
	def test_dict_loader(self, dict_loader):
	env = Environment(loader=dict_loader)
	tmpl = env.get_template("justdict.html")
	assert tmpl.render().strip() == "FOO"
	pytest.raises(TemplateNotFound, env.get_template, "missing.html")

	def test_package_loader(self, package_loader):
	env = Environment(loader=package_loader)
	tmpl = env.get_template("test.html")
	assert tmpl.render().strip() == "BAR"
	pytest.raises(TemplateNotFound, env.get_template, "missing.html")

	def test_filesystem_loader_overlapping_names(self, filesystem_loader):
	res = os.path.dirname(filesystem_loader.searchpath[0])
	t2_dir = os.path.join(res, "templates2")
	# Make "foo" show up before "foo/test.html".
	filesystem_loader.searchpath.insert(0, t2_dir)
	e = Environment(loader=filesystem_loader)
	e.get_template("foo")
	# This would raise NotADirectoryError if "t2/foo" wasn't skipped.
	e.get_template("foo/test.html")

	def test_choice_loader(self, choice_loader):
	env = Environment(loader=choice_loader)
	tmpl = env.get_template("justdict.html")
	assert tmpl.render().strip() == "FOO"
	tmpl = env.get_template("test.html")
	assert tmpl.render().strip() == "BAR"
	pytest.raises(TemplateNotFound, env.get_template, "missing.html")

	def test_function_loader(self, function_loader):
	env = Environment(loader=function_loader)
	tmpl = env.get_template("justfunction.html")
	assert tmpl.render().strip() == "FOO"
	pytest.raises(TemplateNotFound, env.get_template, "missing.html")

	def test_prefix_loader(self, prefix_loader):
	env = Environment(loader=prefix_loader)
	tmpl = env.get_template("a/test.html")
	assert tmpl.render().strip() == "BAR"
	tmpl = env.get_template("b/justdict.html")
	assert tmpl.render().strip() == "FOO"
	pytest.raises(TemplateNotFound, env.get_template, "missing")

	def test_caching(self):
	changed = False

	class TestLoader(loaders.BaseLoader):
	def get_source(self, environment, template):
	return "foo", None, lambda: not changed

	env = Environment(loader=TestLoader(), cache_size=-1)
	tmpl = env.get_template("template")
	assert tmpl is env.get_template("template")
	changed = True
	assert tmpl is not env.get_template("template")
	changed = False

	def test_no_cache(self):
	mapping = {"foo": "one"}
	env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
	assert env.get_template("foo") is not env.get_template("foo")

	def test_limited_size_cache(self):
	mapping = {"one": "foo", "two": "bar", "three": "baz"}
	loader = loaders.DictLoader(mapping)
	env = Environment(loader=loader, cache_size=2)
	t1 = env.get_template("one")
	t2 = env.get_template("two")
	assert t2 is env.get_template("two")
	assert t1 is env.get_template("one")
	env.get_template("three")
	loader_ref = weakref.ref(loader)
	assert (loader_ref, "one") in env.cache
	assert (loader_ref, "two") not in env.cache
	assert (loader_ref, "three") in env.cache

	def test_cache_loader_change(self):
	loader1 = loaders.DictLoader({"foo": "one"})
	loader2 = loaders.DictLoader({"foo": "two"})
	env = Environment(loader=loader1, cache_size=2)
	assert env.get_template("foo").render() == "one"
	env.loader = loader2
	assert env.get_template("foo").render() == "two"

	def test_dict_loader_cache_invalidates(self):
	mapping = {"foo": "one"}
	env = Environment(loader=loaders.DictLoader(mapping))
	assert env.get_template("foo").render() == "one"
	mapping["foo"] = "two"
	assert env.get_template("foo").render() == "two"

	def test_split_template_path(self):
	assert split_template_path("foo/bar") == ["foo", "bar"]
	assert split_template_path("./foo/bar") == ["foo", "bar"]
	pytest.raises(TemplateNotFound, split_template_path, "../foo")


	class TestFileSystemLoader:
	searchpath = os.path.join(
	os.path.dirname(os.path.abspath(__file__)), "res", "templates"
	)

	@staticmethod
	def _test_common(env):
	tmpl = env.get_template("test.html")
	assert tmpl.render().strip() == "BAR"
	tmpl = env.get_template("foo/test.html")
	assert tmpl.render().strip() == "FOO"
	pytest.raises(TemplateNotFound, env.get_template, "missing.html")

	def test_searchpath_as_str(self):
	filesystem_loader = loaders.FileSystemLoader(self.searchpath)

	env = Environment(loader=filesystem_loader)
	self._test_common(env)

	def test_searchpath_as_pathlib(self):
	import pathlib

	searchpath = pathlib.Path(self.searchpath)
	filesystem_loader = loaders.FileSystemLoader(searchpath)
	env = Environment(loader=filesystem_loader)
	self._test_common(env)

	def test_searchpath_as_list_including_pathlib(self):
	import pathlib

	searchpath = pathlib.Path(self.searchpath)
	filesystem_loader = loaders.FileSystemLoader(["/tmp/templates", searchpath])
	env = Environment(loader=filesystem_loader)
	self._test_common(env)

	def test_caches_template_based_on_mtime(self):
	filesystem_loader = loaders.FileSystemLoader(self.searchpath)

	env = Environment(loader=filesystem_loader)
	tmpl1 = env.get_template("test.html")
	tmpl2 = env.get_template("test.html")
	assert tmpl1 is tmpl2

	os.utime(os.path.join(self.searchpath, "test.html"), (time.time(), time.time()))
	tmpl3 = env.get_template("test.html")
	assert tmpl1 is not tmpl3

	@pytest.mark.parametrize(
	("encoding", "expect"),
	[
	("utf-8", "文字化け"),
	("iso-8859-1", "æ\x96\x87\xe5\xad\x97\xe5\x8c\x96\xe3\x81\x91"),
	],
	)
	def test_uses_specified_encoding(self, encoding, expect):
	loader = loaders.FileSystemLoader(self.searchpath, encoding=encoding)
	e = Environment(loader=loader)
	t = e.get_template("mojibake.txt")
	assert t.render() == expect


	class TestModuleLoader:
	archive = None

	def compile_down(self, prefix_loader, zip="deflated"):
	log = []
	self.reg_env = Environment(loader=prefix_loader)
	if zip is not None:
	fd, self.archive = tempfile.mkstemp(suffix=".zip")
	os.close(fd)
	else:
	self.archive = tempfile.mkdtemp()
	self.reg_env.compile_templates(self.archive, zip=zip, log_function=log.append)
	self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
	return "".join(log)

	def teardown(self):
	if hasattr(self, "mod_env"):
	if os.path.isfile(self.archive):
	os.remove(self.archive)
	else:
	shutil.rmtree(self.archive)
	self.archive = None

	def test_log(self, prefix_loader):
	log = self.compile_down(prefix_loader)
	assert (
	'Compiled "a/foo/test.html" as '
	"tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a" in log
	)
	assert "Finished compiling templates" in log
	assert (
	'Could not compile "a/syntaxerror.html": '
	"Encountered unknown tag 'endif'" in log
	)

	def _test_common(self):
	tmpl1 = self.reg_env.get_template("a/test.html")
	tmpl2 = self.mod_env.get_template("a/test.html")
	assert tmpl1.render() == tmpl2.render()

	tmpl1 = self.reg_env.get_template("b/justdict.html")
	tmpl2 = self.mod_env.get_template("b/justdict.html")
	assert tmpl1.render() == tmpl2.render()

	def test_deflated_zip_compile(self, prefix_loader):
	self.compile_down(prefix_loader, zip="deflated")
	self._test_common()

	def test_stored_zip_compile(self, prefix_loader):
	self.compile_down(prefix_loader, zip="stored")
	self._test_common()

	def test_filesystem_compile(self, prefix_loader):
	self.compile_down(prefix_loader, zip=None)
	self._test_common()

	def test_weak_references(self, prefix_loader):
	self.compile_down(prefix_loader)
	self.mod_env.get_template("a/test.html")
	key = loaders.ModuleLoader.get_template_key("a/test.html")
	name = self.mod_env.loader.module.__name__

	assert hasattr(self.mod_env.loader.module, key)
	assert name in sys.modules

	# unset all, ensure the module is gone from sys.modules
	self.mod_env = None

	try:
	import gc

	gc.collect()
	except BaseException:
	pass

	assert name not in sys.modules

	def test_choice_loader(self, prefix_loader):
	self.compile_down(prefix_loader)
	self.mod_env.loader = loaders.ChoiceLoader(
	[self.mod_env.loader, loaders.DictLoader({"DICT_SOURCE": "DICT_TEMPLATE"})]
	)
	tmpl1 = self.mod_env.get_template("a/test.html")
	assert tmpl1.render() == "BAR"
	tmpl2 = self.mod_env.get_template("DICT_SOURCE")
	assert tmpl2.render() == "DICT_TEMPLATE"

	def test_prefix_loader(self, prefix_loader):
	self.compile_down(prefix_loader)
	self.mod_env.loader = loaders.PrefixLoader(
	{
	"MOD": self.mod_env.loader,
	"DICT": loaders.DictLoader({"test.html": "DICT_TEMPLATE"}),
	}
	)
	tmpl1 = self.mod_env.get_template("MOD/a/test.html")
	assert tmpl1.render() == "BAR"
	tmpl2 = self.mod_env.get_template("DICT/test.html")
	assert tmpl2.render() == "DICT_TEMPLATE"

	def test_path_as_pathlib(self, prefix_loader):
	self.compile_down(prefix_loader)

	mod_path = self.mod_env.loader.module.__path__[0]

	import pathlib

	mod_loader = loaders.ModuleLoader(pathlib.Path(mod_path))
	self.mod_env = Environment(loader=mod_loader)

	self._test_common()

	def test_supports_pathlib_in_list_of_paths(self, prefix_loader):
	self.compile_down(prefix_loader)

	mod_path = self.mod_env.loader.module.__path__[0]

	import pathlib

	mod_loader = loaders.ModuleLoader([pathlib.Path(mod_path), "/tmp/templates"])
	self.mod_env = Environment(loader=mod_loader)

	self._test_common()


	@pytest.fixture()
	def package_dir_loader(monkeypatch):
	monkeypatch.syspath_prepend(os.path.dirname(__file__))
	return PackageLoader("res")


	@pytest.mark.parametrize(
	("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
	)
	def test_package_dir_source(package_dir_loader, template, expect):
	source, name, up_to_date = package_dir_loader.get_source(None, template)
	assert source.rstrip() == expect
	assert name.endswith(os.path.join(*split_template_path(template)))
	assert up_to_date()


	def test_package_dir_list(package_dir_loader):
	templates = package_dir_loader.list_templates()
	assert "foo/test.html" in templates
	assert "test.html" in templates


	@pytest.fixture()
	def package_zip_loader(monkeypatch):
	monkeypatch.syspath_prepend(
	os.path.join(os.path.dirname(__file__), "res", "package.zip")
	)
	return PackageLoader("t_pack")


	@pytest.mark.parametrize(
	("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
	)
	def test_package_zip_source(package_zip_loader, template, expect):
	source, name, up_to_date = package_zip_loader.get_source(None, template)
	assert source.rstrip() == expect
	assert name.endswith(os.path.join(*split_template_path(template)))
	assert up_to_date is None


	@pytest.mark.xfail(
	platform.python_implementation() == "PyPy",
	reason="PyPy's zipimporter doesn't have a '_files' attribute.",
	raises=TypeError,
	)
	def test_package_zip_list(package_zip_loader):
	assert package_zip_loader.list_templates() == ["foo/test.html", "test.html"]


	def test_pep_451_import_hook():
	class ImportHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
	def find_spec(self, name, path=None, target=None):
	if name != "res":
	return None

	spec = importlib.machinery.PathFinder.find_spec(name)
	return importlib.util.spec_from_file_location(
	name,
	spec.origin,
	loader=self,
	submodule_search_locations=spec.submodule_search_locations,
	)

	def create_module(self, spec):
	return None # default behaviour is fine

	def exec_module(self, module):
	return None # we need this to satisfy the interface, it's wrong

	# ensure we restore `sys.meta_path` after putting in our loader
	before = sys.meta_path[:]

	try:
	sys.meta_path.insert(0, ImportHook())
	package_loader = PackageLoader("res")
	assert "test.html" in package_loader.list_templates()
	finally:
	sys.meta_path[:] = before