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))