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 Show documentation
Show all versions of jython 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
origImport = __import__
class TestImportStatementError(exceptions.ImportError):
def __init__(self, args):
names = ['name', 'globals', 'locals', 'fromlist', 'level']
self.len = len(args)
for a in args:
n = names.pop(0)
setattr(self, n, 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 TestImportStatementError(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 TestImportStatementError,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 TestImportStatementError")
def testFromDotsOnly(self):
dots = ''
for i in range(1,10):
dots += '.'
a = self.runImport("from %s import (A,B)" % (dots,))
self.assertEqual(a.len, 5)
self.assertEqual(a.name, "")
self.assertEqual(a.level, i)
self.assertEqual(a.fromlist, ('A', 'B'))
def testFromDotsOnlyAs(self):
dots = ''
for i in range(1,10):
dots += '.'
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, i)
def testFromDotsAndName(self):
dots = ''
for i in range(1,10):
dots += '.'
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, i)
def testFromDotsAndDotedName(self):
dots = ''
for i in range(1,10):
dots += '.'
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, i)
def testAbsoluteFromDotedNameAs(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 testRelativeOrAbsoluteFromDotedNameAs(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 testAbsoluteFromDotedNameAll(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 testRelativeOrAbsoluteFromDotedNameAll(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 testAbsoluteImportDotedName(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 testRelativeOrAbsoluteImportDotedName(self):
a = self.runImport("import X.Y")
self.assertEqual(a.name, "X.Y")
self.assertEqual(a.fromlist, None)
self.assertEqual(a.len, 4)
def testAbsoluteImportDotedNameAs(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 TestImportFunctionError(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.
Module Structure:
Top
\---- X package
| \-- Y package
| | \-- Z1 module
| | \-- Z2 module
| \-- Y2 package
\---- X2 module
"""
nameX = "TestImportFunctionX"
def setUp(self):
self.modX = imp.new_module(self.nameX)
self.modX.__path__ = ['X']
self.modX2 = imp.new_module(self.nameX+"2")
self.modY = imp.new_module(self.nameX+".Y")
self.modY.__path__ = ['X/Y']
self.modY2 = imp.new_module(self.nameX+".Y2")
self.modY2.__path__ = ['X/Y']
self.modZ1 = imp.new_module(self.nameX+".Y.Z1")
self.modZ2 = imp.new_module(self.nameX+".Y.Z2")
self.expected = "something_completely_different"
sys.meta_path.insert(0, self)
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
def top(self):
if sys.modules.has_key("__main__"):
return sys.modules["__main__"].__dict__
return globals()
def find_module(self, fullname, path=None):
if self.expected and self.expected != fullname:
return None
self.fullname = fullname
self.path = path
return self
def load_module(self, fullname):
self.assertEqual(fullname, self.fullname)
raise TestImportFunctionError()
def runImport(self, expected, name, globals, fromlist=None, level=None):
self.expected = expected
if isinstance(globals, types.ModuleType):
globals = globals.__dict__
try:
if level is not None:
__import__(name, globals, None, fromlist, level)
else:
__import__(name, globals, None, fromlist)
except TestImportFunctionError:
return
self.fail("Expected a TestImportFunctionError")
def testRelativeOrAbsolute_top_X2_1(self):
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):
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):
self.importX()
self.runImport(None, self.modY.__name__, self.top())
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
def testRelativeOrAbsolute_top_Y_2(self):
self.importX()
self.runImport(None, self.modY.__name__, self.top(), None, -1)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
def testAbsolute_top_X2(self):
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):
self.importX()
self.runImport(None, self.modY.__name__, globals(), None, 0)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
# Relative case
def testRelativeOrAbsolute_X_X2_rel1(self):
self.importX()
self.runImport(None, self.modX2.__name__, self.modX)
self.assertEqual(self.fullname, self.nameX + "." + self.modX2.__name__)
self.assertEqual(self.path, ['X'])
def testRelativeOrAbsolute_X_X2_rel2(self):
self.importX()
self.runImport(None, self.modX2.__name__, self.modX, None, -1)
self.assertEqual(self.path, ['X'])
self.assertEqual(self.fullname, self.nameX + "." + self.modX2.__name__)
# Absolute case
def testRelativeOrAbsolute_X_X2_abs1(self):
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):
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):
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):
self.importX()
self.runImport(None, self.modY.__name__, self.modX, None, 0)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
def testRelative_Z1_Z2(self):
self.importZ1()
self.runImport(None, "", self.modZ1, ['Z2'], 1)
self.assertEqual(self.fullname, self.modZ2.__name__)
self.assertEqual(self.path, ['X/Y'])
def testRelative_Z1_Y2(self):
self.importZ1()
self.runImport(None, "", self.modZ1, ["Y2"], 2)
self.assertEqual(self.fullname, self.modX.__name__+".Y2")
self.assertEqual(self.path, ['X'])
def testRelative_Z1_X2(self):
# """beyond top level"""
self.importZ1()
self.assertRaises(ValueError, self.runImport, None, "", self.modZ1, [self.modX2.__name__], 3)
def testRelative_X2_X(self):
# """not a package"""
self.importX2()
self.assertRaises(ValueError, self.runImport, None, "", self.modX2, [self.modX.__name__], 1)
def testRelative_X2_Y(self):
# """not a package"""
self.importX2()
self.importX()
self.assertRaises(ValueError, self.runImport, None, self.modX.__name__, self.modX2, ["Y"], 1)
def testRelative_X_Z1_1(self):
self.importX()
self.runImport(None, "Y", self.modX, ['Z1'], 1)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
def testRelative_X_Z1_2(self):
self.importY()
self.runImport(None, "Y", self.modX, ['Z1'], 1)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, ['X/Y'])
def testRelative_Y_Z1(self):
self.importY()
self.runImport(None, "Z1", self.modY, ['A', 'B'], 1)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, ['X/Y'])
def testRelative_Y2_Z1_1(self):
self.importY2()
self.runImport(None, "Y", self.modY2, ['Z1'], 2)
self.assertEqual(self.fullname, self.modY.__name__)
self.assertEqual(self.path, ['X'])
def testRelative_Y2_Z1_2(self):
self.importY2()
self.importY()
self.runImport(None, "Y", self.modY2, ['Z1'], 2)
self.assertEqual(self.fullname, self.modZ1.__name__)
self.assertEqual(self.path, ['X/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()