Lib.test.test_import_pep328.py Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-installer Show documentation
Show all versions of jython-installer Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
# test_import_pep328 - Test various aspects of import
#
# Copyright (c) 2010 by science+computing ag
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at#
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/2.4/license for licensing details.
'''
Import related tests:
- Test how 'import ...' and 'from ... import ...' invoke the
'__import__' function.
- Test the module name resolution of the '__import__'-function.
The reference is C-python.
'''
import unittest
import exceptions
import imp
import __builtin__
import sys
import types
EXPLAIN = False # If True, produce commentary in TestImportFunction
MAXDOTS = 10 # adjust enthusiasm of dotted tests
def dump_module(m):
"Print values of attributes relevant to import mechanism"
if isinstance(m, types.ModuleType):
m = m.__dict__
print " Module name: {}".format(m.get('__name__', ''))
for n in ['__package__', '__path__']:
print " {:12s} = {}".format(n, m.get(n,''))
origImport = __import__
class TestImportStatementTell(exceptions.ImportError):
# Raised by TestImportStatement.importFunction to tell us how it was called
def __init__(self, args):
# Smuggle the arguments of importFunction() through the call stack
if EXPLAIN: print "\nimport:"
names = ['name', 'globals', 'locals', 'fromlist', 'level']
self.len = len(args)
for a in args:
n = names.pop(0)
setattr(self, n, a)
if EXPLAIN:
too_long = not isinstance(a, (int, tuple, str, unicode))
print " {:12s}= {}".format(n, a if not too_long else type(a))
for n in names:
setattr(self, n, None)
class TestImportStatement(unittest.TestCase):
"""Test the 'import' and 'from ... import' statements
This class tests, how the compiler calls the
'__import__'-function for various forms of the
'import' and 'from ... import' statements.
"""
AI = "from __future__ import absolute_import ;"
def importFunction(*args):
if args[0] == '__future__':
return origImport(*args)
raise TestImportStatementTell(args)
importFunction = staticmethod(importFunction)
def setUp(self):
__builtin__.__import__ = self.importFunction
def tearDown(self):
__builtin__.__import__ = origImport
def runImport(self, statement):
l = {}
g = {}
try:
exec statement in g, l
except TestImportStatementTell, e:
self.assert_(e.globals is g, "globals is changed")
self.assert_(e.locals is l, "locals is changed")
return e
self.fail("Expected a TestImportStatementTell")
@staticmethod
def dotrange(n=MAXDOTS):
"Return a longer sequence of dots in each iteration"
for i in range(1, n):
yield '.'*i
def testFromDotsOnly(self):
for dots in self.dotrange():
a = self.runImport("from %s import (A,B)" % (dots,))
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "")
self.assertEqual(a.level, len(dots))
self.assertEqual(a.fromlist, ('A', 'B'))
def testFromDotsOnlyAs(self):
for dots in self.dotrange():
a = self.runImport("from %s import A as B" % (dots,))
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "")
self.assertEqual(a.fromlist, ('A',))
self.assertEqual(a.level, len(dots))
def testFromDotsAndName(self):
for dots in self.dotrange():
a = self.runImport("from %sX import A" % (dots,))
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X")
self.assertEqual(a.fromlist, ('A',))
self.assertEqual(a.level, len(dots))
def testFromDotsAndDottedName(self):
for dots in self.dotrange():
a = self.runImport("from %sX.Y import A" % (dots,))
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('A',))
self.assertEqual(a.level, len(dots))
def testFromDotsAndDottedNameAll(self):
for dots in self.dotrange():
a = self.runImport("from %sX.Y import *" % (dots,))
self.assertEqual(a.len, 5, "level argument elided") # Issue 2158
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('*',))
self.assertEqual(a.level, len(dots))
def testAbsoluteFromDottedNameAs(self):
a = self.runImport(self.AI + "from X.Y import A as B")
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('A',))
self.assertEqual(a.level, 0)
def testRelativeOrAbsoluteFromDottedNameAs(self):
a = self.runImport("from X.Y import A as B")
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('A',))
self.assertEqual(a.len, 4)
def testAbsoluteFromDottedNameAll(self):
a = self.runImport(self.AI + "from X.Y import *")
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('*',))
self.assertEqual(a.level, 0)
def testRelativeOrAbsoluteFromDottedNameAll(self):
a = self.runImport("from X.Y import *")
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, ('*',))
self.assertEqual(a.len, 4)
def testAbsoluteImportName(self):
a = self.runImport(self.AI + "import X")
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.level, 0)
def testAbsoluteImportDottedName(self):
a = self.runImport(self.AI + "import X.Y")
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.level, 0)
def testRelativeOrAbsoluteImportName(self):
a = self.runImport("import X")
self.assertEqual(a.name, "X")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.len, 4)
def testRelativeOrAbsoluteImportDottedName(self):
a = self.runImport("import X.Y")
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.len, 4)
def testAbsoluteImportDottedNameAs(self):
a = self.runImport(self.AI + "import X.Y as Z")
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.level, 0)
class TestImportFunctionSuccess(exceptions.ImportError):
pass
class TestImportFunction(unittest.TestCase):
"""Test the '__import__' function
This class tests, how the '__import__'-function resolves module names.
It uses the 'meta_path' hook, to intercept the actual module loading.
When consulted through find_module, it claims to have access to the
following module structure:
Top
+---- X package
| +-- Y package
| | +-- Z1 module
| | +-- Z2 module
| +-- Y2 package
+---- X2 module
"""
nameX = "TestImportFunctionX"
def setUp(self):
self.modX = self._new_module(None, self.nameX, True)
self.modY = self._new_module(self.modX, "Y", True)
self.modZ1 = self._new_module(self.modY, "Z1")
self.modZ2 = self._new_module(self.modY, "Z2")
self.modY2 = self._new_module(self.modX, "Y2", True)
self.modX2 = self._new_module(None, self.nameX + "2")
self.expected = "something_completely_different"
sys.meta_path.insert(0, self)
@staticmethod
def _new_module(in_package, name, is_package=False):
if not in_package:
m = imp.new_module(name)
else:
m = imp.new_module(in_package.__name__ + '.' + name)
if is_package:
m.__package__ = m.__name__ # surprisingly not the parent name
else:
m.__package__ = in_package.__name__
if is_package:
m.__path__ = [m.__name__.replace('.', '/')]
return m
def tearDown(self):
try:
sys.meta_path.remove(self)
except ValueError:
pass
for k in sys.modules.keys():
if k.startswith(self.nameX):
del sys.modules[k]
def importX(self):
sys.modules[self.modX.__name__] = self.modX
def importX2(self):
sys.modules[self.modX2.__name__] = self.modX2
def importY(self):
self.importX()
sys.modules[self.modY.__name__] = self.modY
self.modX.Y = self.modY
def importY2(self):
self.importX()
sys.modules[self.modY2.__name__] = self.modY2
self.modX.Y2 = self.modY2
def importZ1(self):
self.importY()
sys.modules[self.modZ1.__name__] = self.modZ1
self.modY.Z1 = self.modZ1
@staticmethod
def top():
"Return the __dict__ of a non-package, top-level module"
# When this program runs as python -m test.test_import_pep328, it is
# called __main__, but is inside package test, so we must fake it.
myName = TestImportFunction.nameX[:-1] + "Top"
return {'__name__': myName, '__package__': None, '__file__': None}
def find_module(self, fullname, path=None):
# Simulate the operation of a module finder object on the sys.meta_path
if EXPLAIN:
print "find_module:"
print " fullname =", fullname
print " path =", path
if self.expected and self.expected != fullname:
# Equivalent of "import name" was called and the import mechanism is
# trying something other than the expected full name. For example, X
# called "import X2", and something other than X2 is tried (first).
return None
self.fullname = fullname
self.path = path
return self
def load_module(self, fullname):
# Masquerade as the loader matching fullname
self.assertEqual(fullname, self.fullname)
# Signal success, disguised as an ImportError
raise TestImportFunctionSuccess()
def runImport(self, expected, name, globals, fromlist=None, level=None):
self.expected = expected
if isinstance(globals, types.ModuleType):
globals = globals.__dict__
if EXPLAIN:
print "\nrunImport:"
dotname = ('.'*level if level>0 else '') + name
callername = globals['__name__']
callerpkg = globals.get('__package__', None)
if fromlist:
print " from {} import {} # in {} in package {}".format(
dotname, fromlist, callername, callerpkg)
else:
print " import {} # in {} in package {}".format(
dotname, callername, callerpkg)
try:
if level is not None:
__import__(name, globals, None, fromlist, level)
else:
__import__(name, globals, None, fromlist)
except TestImportFunctionSuccess:
return
self.fail("Expected a TestImportFunctionSuccess")
def testRelativeOrAbsolute_top_X2_1(self):
# In context of a non-package, top-level module, find X2.
# The finder should only be consulted with the absolute name.
self.runImport(None, self.modX2.__name__, self.top())
self.assertEqual(self.fullname, self.modX2.__name__)
self.assertEqual(self.path, None)
def testRelativeOrAbsolute_top_X2_2(self):
# In context of a non-package, top-level module, find X2.
# The finder should only be consulted with the absolute name.
self.runImport(None, self.modX2.__name__, self.top(), None, -1)
self.assertEqual(self.fullname, self.modX2.__name__)
self.assertEqual(self.path, None)
def testRelativeOrAbsolute_top_Y_1(self):
# In context of a non-package, top-level module, find X.Y.
# The finder should only be consulted with the absolute name.
self.importX()
self.runImport(None, self.modY.__name__, self.top())
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
def testRelativeOrAbsolute_top_Y_2(self):
# In context of a non-package, top-level module, find X.Y.
# The finder should only be consulted with the absolute name.
self.importX()
self.runImport(None, self.modY.__name__, self.top(), None, -1)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
def testAbsolute_top_X2(self):
# In context of a non-package, top-level module, find X2 absolutely.
self.runImport(None, self.modX2.__name__, globals(), None, 0)
self.assertEqual(self.fullname, self.modX2.__name__)
self.assertEqual(self.path, None)
def testAbsolute_top_Y(self):
# In context of a non-package, top-level module, find X.Y absolutely.
self.importX()
self.runImport(None, self.modY.__name__, globals(), None, 0)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
# Relative case
def testRelativeOrAbsolute_X_X2_rel1(self):
# In context of package X, look for X2 at X.X2 (where actually it isn't).
self.importX()
self.runImport(None, self.modX2.__name__, self.modX)
self.assertEqual(self.fullname, self.nameX + "." + self.modX2.__name__)
self.assertEqual(self.path, [self.nameX])
def testRelativeOrAbsolute_X_X2_rel2(self):
# In context of package X, look for X2 at X.X2 (where actually it isn't).
self.importX()
self.runImport(None, self.modX2.__name__, self.modX, None, -1)
self.assertEqual(self.path, [self.nameX])
self.assertEqual(self.fullname, self.nameX + "." + self.modX2.__name__)
# Absolute case
def testRelativeOrAbsolute_X_X2_abs1(self):
# In context of package X, find X2 at absolute X2 (on second attempt).
self.importX()
self.runImport(self.modX2.__name__, self.modX2.__name__, self.modX)
self.assertEqual(self.fullname, self.modX2.__name__)
self.assertEqual(self.path, None)
def testRelativeOrAbsolute_X_X2_abs2(self):
# In context of package X, find X2 at absolute X2 (on second attempt).
self.importX()
self.runImport(self.modX2.__name__, self.modX2.__name__, self.modX, None, -1)
self.assertEqual(self.path, None)
self.assertEqual(self.fullname, self.modX2.__name__)
def testAbsolute_X_X2(self):
# In context of package X, find X2 at explicitly absolute X2.
self.importX()
self.runImport(None, self.modX2.__name__, self.modX, None, 0)
self.assertEqual(self.fullname, self.modX2.__name__)
self.assertEqual(self.path, None)
def testAbsolute_X_Y(self):
# In context of package X, find Y at explicitly absolute X.Y.
self.importX()
self.runImport(None, self.modY.__name__, self.modX, None, 0)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
def testRelative_Z1_Z2(self):
# In context of module Z1, from . import Z2.
self.importZ1()
self.runImport(None, "", self.modZ1, ['Z2'], 1)
self.assertEqual(self.fullname, self.modZ2.__name__)
self.assertEqual(self.path, [self.nameX + '/Y'])
def testRelative_Z1_Y2(self):
# In context of module Z1, from .. import Y2.
self.importZ1()
self.runImport(None, "", self.modZ1, ["Y2"], 2)
self.assertEqual(self.fullname, self.modX.__name__ + ".Y2")
self.assertEqual(self.path, [self.nameX])
def testRelative_Z1_X2(self):
# In context of module Z1, from ... import X2 (incorrectly beyond top level).
self.importZ1()
with self.assertRaises(ValueError):
self.runImport(None, "", self.modZ1, [self.modX2.__name__], 3)
def testRelative_X2_X(self):
# In context of module X2, from . import X (incorrectly)
# This is incorrect as X2 is not in a package (is a top-level module).
self.importX2()
with self.assertRaises(ValueError):
self.runImport(None, "", self.modX2, [self.modX.__name__], 1)
def testRelative_X2_Y(self):
# In context of module X2, from .X import Y (incorrectly).
# This is incorrect as X2 is not in a package (is a top-level module).
self.importX2()
self.importX()
with self.assertRaises(ValueError):
self.runImport(None, self.modX.__name__, self.modX2, ["Y"], 1)
def testRelative_X_Z1_1(self):
# In context of package X, from .Y import Z1.
self.importX()
self.runImport(None, "Y", self.modX, ['Z1'], 1)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
def testRelative_X_Z1_2(self):
# In context of package X, from .Y import Z1.
self.importY()
self.runImport(None, "Y", self.modX, ['Z1'], 1)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, [self.nameX + '/Y'])
def testRelative_Y_Z1(self):
# In context of package Y: from .Z1 import A, B.
self.importY()
self.runImport(None, "Z1", self.modY, ['A', 'B'], 1)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, [self.nameX + '/Y'])
def testRelative_Y2_Z1_1(self):
# In context of package Y2, from ..Y import Z1.
self.importY2()
self.runImport(None, "Y", self.modY2, ['Z1'], 2)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, [self.nameX])
def testRelative_Y2_Z1_2(self):
# In context of package Y2, from ..Y import Z1.
self.importY2()
self.importY()
self.runImport(None, "Y", self.modY2, ['Z1'], 2)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, [self.nameX + '/Y'])
try:
from test import test_support
except ImportError:
test_main = unittest.main
else:
def test_main():
test_support.run_unittest(
TestImportStatement,
TestImportFunction,
)
if __name__ == '__main__':
test_main()