/Lib/test/test_zipimport_support.py
Python | 244 lines | 190 code | 15 blank | 39 comment | 15 complexity | fedcdc4608eaca69e7e0ba7d1dae4a99 MD5 | raw file
- # This test module covers support in various parts of the standard library
- # for working with modules located inside zipfiles
- # The tests are centralised in this fashion to make it easy to drop them
- # if a platform doesn't support zipimport
- import test.support
- import os
- import os.path
- import sys
- import textwrap
- import zipfile
- import zipimport
- import doctest
- import inspect
- import linecache
- import unittest
- from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
- make_script, make_zip_script)
- verbose = test.support.verbose
- # Library modules covered by this test set
- # pdb (Issue 4201)
- # inspect (Issue 4223)
- # doctest (Issue 4197)
- # Other test modules with zipimport related tests
- # test_zipimport (of course!)
- # test_cmd_line_script (covers the zipimport support in runpy)
- # Retrieve some helpers from other test cases
- from test import (test_doctest, sample_doctest, sample_doctest_no_doctests,
- sample_doctest_no_docstrings)
- def _run_object_doctest(obj, module):
- finder = doctest.DocTestFinder(verbose=verbose, recurse=False)
- runner = doctest.DocTestRunner(verbose=verbose)
- # Use the object's fully qualified name if it has one
- # Otherwise, use the module's name
- try:
- name = "%s.%s" % (obj.__module__, obj.__qualname__)
- except AttributeError:
- name = module.__name__
- for example in finder.find(obj, name, module):
- runner.run(example)
- f, t = runner.failures, runner.tries
- if f:
- raise test.support.TestFailed("%d of %d doctests failed" % (f, t))
- if verbose:
- print ('doctest (%s) ... %d tests with zero failures' % (module.__name__, t))
- return f, t
- class ZipSupportTests(unittest.TestCase):
- # This used to use the ImportHooksBaseTestCase to restore
- # the state of the import related information
- # in the sys module after each test. However, that restores
- # *too much* information and breaks for the invocation
- # of test_doctest. So we do our own thing and leave
- # sys.modules alone.
- # We also clear the linecache and zipimport cache
- # just to avoid any bogus errors due to name reuse in the tests
- def setUp(self):
- linecache.clearcache()
- zipimport._zip_directory_cache.clear()
- self.path = sys.path[:]
- self.meta_path = sys.meta_path[:]
- self.path_hooks = sys.path_hooks[:]
- sys.path_importer_cache.clear()
- def tearDown(self):
- sys.path[:] = self.path
- sys.meta_path[:] = self.meta_path
- sys.path_hooks[:] = self.path_hooks
- sys.path_importer_cache.clear()
- def test_inspect_getsource_issue4223(self):
- test_src = "def foo(): pass\n"
- with test.support.temp_dir() as d:
- init_name = make_script(d, '__init__', test_src)
- name_in_zip = os.path.join('zip_pkg',
- os.path.basename(init_name))
- zip_name, run_name = make_zip_script(d, 'test_zip',
- init_name, name_in_zip)
- os.remove(init_name)
- sys.path.insert(0, zip_name)
- import zip_pkg
- try:
- self.assertEqual(inspect.getsource(zip_pkg.foo), test_src)
- finally:
- del sys.modules["zip_pkg"]
- def test_doctest_issue4197(self):
- # To avoid having to keep two copies of the doctest module's
- # unit tests in sync, this test works by taking the source of
- # test_doctest itself, rewriting it a bit to cope with a new
- # location, and then throwing it in a zip file to make sure
- # everything still works correctly
- test_src = inspect.getsource(test_doctest)
- test_src = test_src.replace(
- "from test import test_doctest",
- "import test_zipped_doctest as test_doctest")
- test_src = test_src.replace("test.test_doctest",
- "test_zipped_doctest")
- test_src = test_src.replace("test.sample_doctest",
- "sample_zipped_doctest")
- # The sample doctest files rewritten to include in the zipped version.
- sample_sources = {}
- for mod in [sample_doctest, sample_doctest_no_doctests,
- sample_doctest_no_docstrings]:
- src = inspect.getsource(mod)
- src = src.replace("test.test_doctest", "test_zipped_doctest")
- # Rewrite the module name so that, for example,
- # "test.sample_doctest" becomes "sample_zipped_doctest".
- mod_name = mod.__name__.split(".")[-1]
- mod_name = mod_name.replace("sample_", "sample_zipped_")
- sample_sources[mod_name] = src
- with test.support.temp_dir() as d:
- script_name = make_script(d, 'test_zipped_doctest',
- test_src)
- zip_name, run_name = make_zip_script(d, 'test_zip',
- script_name)
- z = zipfile.ZipFile(zip_name, 'a')
- for mod_name, src in sample_sources.items():
- z.writestr(mod_name + ".py", src)
- z.close()
- if verbose:
- zip_file = zipfile.ZipFile(zip_name, 'r')
- print ('Contents of %r:' % zip_name)
- zip_file.printdir()
- zip_file.close()
- os.remove(script_name)
- sys.path.insert(0, zip_name)
- import test_zipped_doctest
- try:
- # Some of the doc tests depend on the colocated text files
- # which aren't available to the zipped version (the doctest
- # module currently requires real filenames for non-embedded
- # tests). So we're forced to be selective about which tests
- # to run.
- # doctest could really use some APIs which take a text
- # string or a file object instead of a filename...
- known_good_tests = [
- test_zipped_doctest.SampleClass,
- test_zipped_doctest.SampleClass.NestedClass,
- test_zipped_doctest.SampleClass.NestedClass.__init__,
- test_zipped_doctest.SampleClass.__init__,
- test_zipped_doctest.SampleClass.a_classmethod,
- test_zipped_doctest.SampleClass.a_property,
- test_zipped_doctest.SampleClass.a_staticmethod,
- test_zipped_doctest.SampleClass.double,
- test_zipped_doctest.SampleClass.get,
- test_zipped_doctest.SampleNewStyleClass,
- test_zipped_doctest.SampleNewStyleClass.__init__,
- test_zipped_doctest.SampleNewStyleClass.double,
- test_zipped_doctest.SampleNewStyleClass.get,
- test_zipped_doctest.sample_func,
- test_zipped_doctest.test_DocTest,
- test_zipped_doctest.test_DocTestParser,
- test_zipped_doctest.test_DocTestRunner.basics,
- test_zipped_doctest.test_DocTestRunner.exceptions,
- test_zipped_doctest.test_DocTestRunner.option_directives,
- test_zipped_doctest.test_DocTestRunner.optionflags,
- test_zipped_doctest.test_DocTestRunner.verbose_flag,
- test_zipped_doctest.test_Example,
- test_zipped_doctest.test_debug,
- test_zipped_doctest.test_testsource,
- test_zipped_doctest.test_trailing_space_in_test,
- test_zipped_doctest.test_DocTestSuite,
- test_zipped_doctest.test_DocTestFinder,
- ]
- # These tests are the ones which need access
- # to the data files, so we don't run them
- fail_due_to_missing_data_files = [
- test_zipped_doctest.test_DocFileSuite,
- test_zipped_doctest.test_testfile,
- test_zipped_doctest.test_unittest_reportflags,
- ]
- for obj in known_good_tests:
- _run_object_doctest(obj, test_zipped_doctest)
- finally:
- del sys.modules["test_zipped_doctest"]
- def test_doctest_main_issue4197(self):
- test_src = textwrap.dedent("""\
- class Test:
- ">>> 'line 2'"
- pass
- import doctest
- doctest.testmod()
- """)
- pattern = 'File "%s", line 2, in %s'
- with test.support.temp_dir() as d:
- script_name = make_script(d, 'script', test_src)
- rc, out, err = assert_python_ok(script_name)
- expected = pattern % (script_name, "__main__.Test")
- if verbose:
- print ("Expected line", expected)
- print ("Got stdout:")
- print (ascii(out))
- self.assertIn(expected.encode('utf-8'), out)
- zip_name, run_name = make_zip_script(d, "test_zip",
- script_name, '__main__.py')
- rc, out, err = assert_python_ok(zip_name)
- expected = pattern % (run_name, "__main__.Test")
- if verbose:
- print ("Expected line", expected)
- print ("Got stdout:")
- print (ascii(out))
- self.assertIn(expected.encode('utf-8'), out)
- def test_pdb_issue4201(self):
- test_src = textwrap.dedent("""\
- def f():
- pass
- import pdb
- pdb.Pdb(nosigint=True).runcall(f)
- """)
- with test.support.temp_dir() as d:
- script_name = make_script(d, 'script', test_src)
- p = spawn_python(script_name)
- p.stdin.write(b'l\n')
- data = kill_python(p)
- # bdb/pdb applies normcase to its filename before displaying
- self.assertIn(os.path.normcase(script_name.encode('utf-8')), data)
- zip_name, run_name = make_zip_script(d, "test_zip",
- script_name, '__main__.py')
- p = spawn_python(zip_name)
- p.stdin.write(b'l\n')
- data = kill_python(p)
- # bdb/pdb applies normcase to its filename before displaying
- self.assertIn(os.path.normcase(run_name.encode('utf-8')), data)
- def tearDownModule():
- test.support.reap_children()
- if __name__ == '__main__':
- unittest.main()