def check_result(self, expected, from_strings):
proc = lazy_import.ImportProcessor()
for from_str in from_strings:
proc._convert_from_str(from_str)
self.assertEqual(
expected, proc.imports, 'Import of %r was not converted correctly'
' %s != %s' % (from_strings, expected, proc.imports))
def check(self, expected, text):
proc = lazy_import.ImportProcessor()
proc._build_map(text)
self.assertEqual(
expected, proc.imports,
'Incorrect processing of:\n%s\n%s\n!=\n%s' %
(text, expected, proc.imports))
def check(self, expected, import_strings):
proc = lazy_import.ImportProcessor()
for import_str in import_strings:
proc._convert_import_str(import_str)
self.assertEqual(
expected, proc.imports, 'Import of %r was not converted correctly'
' %s != %s' % (import_strings, expected, proc.imports))
def test_import_deep(self):
"""Test import root.mod, root.sub.submoda, root.sub.submodb
root should be a lazy import, with multiple children, who also
have children to be imported.
And when root is imported, the children should be lazy, and
reuse the intermediate lazy object.
"""
try:
submoda7
except NameError:
pass # submoda7 should not be defined yet
else:
self.fail('submoda7 was not supposed to exist yet')
text = """\
import %(root_name)s.%(sub_name)s.%(submoda_name)s as submoda7
""" % self.__dict__
proc = lazy_import.ImportProcessor(InstrumentedImportReplacer)
proc.lazy_import(scope=globals(), text=text)
# So 'submoda7' should be a lazy import
self.assertEqual(InstrumentedImportReplacer,
object.__getattribute__(submoda7, '__class__'))
# This should import submoda7
self.assertEqual(4, submoda7.var4)
sub_path = self.root_name + '.' + self.sub_name
submoda_path = sub_path + '.' + self.submoda_name
self.assertEqual([
('__getattribute__', 'var4'),
('_import', 'submoda7'),
('import', submoda_path, [], 0),
], self.actions)
def test_incorrect_line(self):
proc = lazy_import.ImportProcessor()
self.assertRaises(errors.InvalidImportLine, proc._build_map,
'foo bar baz')
self.assertRaises(errors.InvalidImportLine, proc._build_map,
'improt foo')
self.assertRaises(errors.InvalidImportLine, proc._build_map,
'importfoo')
self.assertRaises(errors.InvalidImportLine, proc._build_map,
'fromimport')
def test_name_collision(self):
proc = lazy_import.ImportProcessor()
proc._build_map('import foo')
# All of these would try to create an object with the
# same name as an existing object.
self.assertRaises(errors.ImportNameCollision, proc._build_map,
'import bar as foo')
self.assertRaises(errors.ImportNameCollision, proc._build_map,
'from foo import bar as foo')
self.assertRaises(errors.ImportNameCollision, proc._build_map,
'from bar import foo')
def test_root(self):
try:
root6
except NameError:
pass # root6 should not be defined yet
else:
self.fail('root6 was not supposed to exist yet')
text = 'import %s as root6' % (self.root_name, )
proc = lazy_import.ImportProcessor(InstrumentedImportReplacer)
proc.lazy_import(scope=globals(), text=text)
# So 'root6' should be a lazy import
self.assertEqual(InstrumentedImportReplacer,
object.__getattribute__(root6, '__class__'))
self.assertEqual(1, root6.var1)
self.assertEqual('x', root6.func1('x'))
self.assertEqual([
('__getattribute__', 'var1'),
('_import', 'root6'),
('import', self.root_name, [], 0),
], self.actions)
def test_missing_trailing(self):
proc = lazy_import.ImportProcessor()
self.assertRaises(errors.InvalidImportLine,
proc._canonicalize_import_text,
"from foo import (\n bar\n")
def check(self, expected, text):
proc = lazy_import.ImportProcessor()
parsed = proc._canonicalize_import_text(text)
self.assertEqual(
expected, parsed, 'Incorrect parsing of text:\n%s\n%s\n!=\n%s' %
(text, expected, parsed))
