def setUp(self):
super(AutoImportObservingTest, self).setUp()
self.project = testutils.sample_project()
self.mod1 = testutils.create_module(self.project, "mod1")
self.pkg = testutils.create_package(self.project, "pkg")
self.mod2 = testutils.create_module(self.project, "mod2", self.pkg)
self.importer = autoimport.AutoImport(self.project, observe=True)
def test_not_reaching_maximum_recursions_when_importing_variables(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('from mod2 import myvar\n')
mod2.write('from mod1 import myvar\n')
pymod1 = self.pycore.resource_to_pyobject(mod1)
pymod1['myvar'].get_object()
def setUp(self):
super(AutoImportTest, self).setUp()
self.project = testutils.sample_project(extension_modules=["sys"])
self.mod1 = testutils.create_module(self.project, "mod1")
self.pkg = testutils.create_package(self.project, "pkg")
self.mod2 = testutils.create_module(self.project, "mod2", self.pkg)
self.importer = autoimport.AutoImport(self.project, observe=False)
def test_get_definition_location_for_filtered_packages(self):
pkg = testutils.create_package(self.project, 'pkg')
testutils.create_module(self.project, 'mod', pkg)
init_module = self.pycore.get_module('pkg.__init__')
mod = self.pycore.get_string_module('import pkg.mod')
pkg_pyname = mod['pkg']
self.assertEquals((init_module, 1), pkg_pyname.get_definition_location())
def test_not_reaching_maximum_recursions_with_from_star_imports(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('from mod2 import *\n')
mod2.write('from mod1 import *\n')
pymod1 = self.pycore.resource_to_pyobject(mod1)
pymod1.get_attributes()
def setUp(self):
super(AutoImportTest, self).setUp()
self.project = testutils.sample_project()
self.mod1 = testutils.create_module(self.project, 'mod1')
self.pkg = testutils.create_package(self.project, 'pkg')
self.mod2 = testutils.create_module(self.project, 'mod2', self.pkg)
self.importer = autoimport.AutoImport(self.project, observe=False)
def test_imported_as_names(self):
testutils.create_module(self.project, 'mod1')
mod = testutils.create_module(self.project, 'mod2')
mod.write('import mod1 as my_import\n')
module = self.pycore.get_module('mod2')
imported_mod = module['my_import'].get_object()
self.assertEquals(get_base_type('Module'), imported_mod.get_type())
def setUp(self):
super(GenerateTest, self).setUp()
self.project = testutils.sample_project()
self.pycore = self.project.get_pycore()
self.mod = testutils.create_module(self.project, 'mod1')
self.mod2 = testutils.create_module(self.project, 'mod2')
self.pkg = testutils.create_package(self.project, 'pkg')
def test_imported_names(self):
testutils.create_module(self.project, 'mod1')
mod = testutils.create_module(self.project, 'mod2')
mod.write('import mod1\n')
module = self.project.get_module('mod2')
imported_sys = module['mod1'].get_object()
self.assertEquals(get_base_type('Module'), imported_sys.get_type())
def test_get_pyname_definition_location_importes(self):
testutils.create_module(self.project, 'mod')
mod = libutils.get_string_module(self.project, 'import mod\n')
imported_module = self.project.get_module('mod')
module_pyname = mod['mod']
self.assertEquals((imported_module, 1),
module_pyname.get_definition_location())
def test_completing_names_after_from_import2(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('myvar = None\n')
result = self._assist('from mod1 import ', resource=mod2)
self.assertTrue(len(result) > 0)
self.assert_completion_in_result('myvar', 'global', result)
def xxx_test_from_package_import_package(self):
pkg1 = testutils.create_package(self.project, 'pkg1')
pkg2 = testutils.create_package(self.project, 'pkg2', pkg1)
testutils.create_module(self.project, 'mod', pkg2)
mod = self.pycore.get_string_module('from pkg1 import pkg2\n')
package = mod['pkg2']
self.assertEquals(0, len(package.get_attributes()))
def test_circular_imports2(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write(
'from mod2 import Sample2\nclass Sample1(object):\n pass\n')
mod2.write(
'from mod1 import Sample1\nclass Sample2(object):\n pass\n')
self.project.get_module('mod1').get_attributes()
def test_find_occurrences_resources_parameter(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('a_var = 1\n')
mod2.write('import mod1\nmy_var = mod1.a_var')
result = find_occurrences(self.project, mod1, 1, resources=[mod1])
self.assertEquals(1, len(result))
self.assertEquals((mod1, 0), (result[0].resource, result[0].offset))
def test_renaming_resources_using_rename_module_refactoring(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('a_var = 1')
mod2.write('import mod1\nmy_var = mod1.a_var\n')
renamer = rename.Rename(self.project, mod1)
renamer.get_changes('newmod').do()
self.assertEquals('import newmod\nmy_var = newmod.a_var\n', mod2.read())
def test_relative_imports_for_string_scopes(self):
pkg = testutils.create_package(self.project, 'pkg')
mod1 = testutils.create_module(self.project, 'mod1', pkg)
mod2 = testutils.create_module(self.project, 'mod2', pkg)
mod2.write('import mod1\n')
mod1_object = self.pycore.resource_to_pyobject(mod1)
mod2_scope = self.pycore.get_string_scope(mod2.read(), mod2)
self.assertEquals(mod1_object, mod2_scope['mod1'].get_object())
def setUp(self):
super(AddImportTest, self).setUp()
self.project = testutils.sample_project()
self.mod1 = testutils.create_module(self.project, "mod1")
self.mod2 = testutils.create_module(self.project, "mod2")
self.pkg = testutils.create_package(self.project, "pkg")
self.mod3 = testutils.create_module(self.project, "mod3", self.pkg)
def test_module_dti(self):
mod1 = testutils.create_module(self.project, "mod1")
mod2 = testutils.create_module(self.project, "mod2")
code = 'import mod1\ndef a_func(arg):\n return eval("arg")\n' "a_var = a_func(mod1)\n"
mod2.write(code)
self.pycore.run_module(mod2).wait_process()
pymod2 = self.pycore.resource_to_pyobject(mod2)
self.assertEquals(self.pycore.resource_to_pyobject(mod1), pymod2["a_var"].get_object())
def test_new_style_relative_imports(self):
pkg = testutils.create_package(self.project, 'pkg')
mod1 = testutils.create_module(self.project, 'mod1', pkg)
mod2 = testutils.create_module(self.project, 'mod2', pkg)
mod2.write('from . import mod1\n')
mod1_object = self.pycore.resource_to_pyobject(mod1)
mod2_object = self.pycore.resource_to_pyobject(mod2)
self.assertEquals(mod1_object, mod2_object['mod1'].get_object())
def test_nested_modules(self):
pkg = testutils.create_package(self.project, 'pkg')
testutils.create_module(self.project, 'mod', pkg)
imported_module = self.project.get_module('pkg.mod')
scope = libutils.get_string_scope(self.project, 'import pkg.mod\n')
mod_pyobject = scope['pkg'].get_object()['mod']
self.assertEquals((imported_module, 1),
mod_pyobject.get_definition_location())
def test_assist_on_relative_imports(self):
pkg = testutils.create_package(self.project, 'pkg')
mod1 = testutils.create_module(self.project, 'mod1', pkg)
mod2 = testutils.create_module(self.project, 'mod2', pkg)
mod1.write('def a_func():\n pass\n')
code = 'import mod1\nmod1.'
result = self._assist(code, resource=mod2)
self.assert_completion_in_result('a_func', 'attribute', result)
def test_get_doc_on_relative_imports(self):
pkg = testutils.create_package(self.project, 'pkg')
mod1 = testutils.create_module(self.project, 'mod1', pkg)
mod2 = testutils.create_module(self.project, 'mod2', pkg)
mod1.write('def a_func():\n """hey"""\n pass\n')
code = 'import mod1\nmod1.a_func\n'
result = get_doc(self.project, code, len(code) - 2, mod2)
self.assertTrue(result.endswith('hey'))
def test_from_package_import_module_get_definition_location(self):
pkg = testutils.create_package(self.project, 'pkg')
testutils.create_module(self.project, 'mod', pkg)
pkg_mod = self.pycore.get_module('pkg.mod')
mod = self.pycore.get_string_module('from pkg import mod\n')
imported_mod = mod['mod']
self.assertEquals((pkg_mod, 1),
imported_mod.get_definition_location())
def test_applying_all_changes_together(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('import mod2\nmod2.a_func()\n')
mod2 = testutils.create_module(self.project, 'mod2')
mod2.write('def a_func():\n pass\na_func()\n')
self._rename(mod2, len(mod2.read()) - 5, 'new_func')
self.assertEquals('import mod2\nmod2.new_func()\n', mod1.read())
self.assertEquals('def new_func():\n pass\nnew_func()\n',
mod2.read())
def test_renaming_modules_aliased(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('def a_func():\n pass\n')
mod2 = testutils.create_module(self.project, 'mod2')
mod2.write('import mod1 as m\nm.a_func()\n')
self._rename(mod1, None, 'newmod')
self.assertTrue(not mod1.exists() and
self.project.find_module('newmod') is not None)
self.assertEquals('import newmod as m\nm.a_func()\n', mod2.read())
def test_renaming_modules(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('def a_func():\n pass\n')
mod2 = testutils.create_module(self.project, 'mod2')
mod2.write('from mod1 import a_func\n')
self._rename(mod2, mod2.read().index('mod1') + 1, 'newmod')
self.assertTrue(not mod1.exists() and
self.project.find_module('newmod') is not None)
self.assertEquals('from newmod import a_func\n', mod2.read())
def test_get_location_on_relative_imports(self):
pkg = testutils.create_package(self.project, 'pkg')
mod1 = testutils.create_module(self.project, 'mod1', pkg)
mod2 = testutils.create_module(self.project, 'mod2', pkg)
mod1.write('def a_func():\n pass\n')
code = 'import mod1\nmod1.a_func\n'
result = get_definition_location(self.project, code,
len(code) - 2, mod2)
self.assertEquals((mod1, 1), result)
def test_resources_parameter_not_changing_defining_module(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod2 = testutils.create_module(self.project, 'mod2')
mod1.write('def f():\n pass\n')
mod2.write('import mod1\nmod1.f()\n')
self._rename(mod1, mod1.read().rindex('f'), 'g',
resources=[mod2])
self.assertEquals('def f():\n pass\n', mod1.read())
self.assertEquals('import mod1\nmod1.g()\n', mod2.read())
def test_renaming_functions_from_another_module(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('def a_func():\n pass\na_func()\n')
mod2 = testutils.create_module(self.project, 'mod2')
mod2.write('import mod1\nmod1.a_func()\n')
self._rename(mod2, len(mod2.read()) - 5, 'new_func')
self.assertEquals('def new_func():\n pass\nnew_func()\n',
mod1.read())
self.assertEquals('import mod1\nmod1.new_func()\n', mod2.read())
def test_undoing_renaming_modules(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('def a_func():\n pass\n')
mod2 = testutils.create_module(self.project, 'mod2')
mod2.write('from mod1 import a_func\n')
self._rename(mod2, 6, 'newmod')
self.project.history.undo()
self.assertEquals('mod1.py', mod1.path)
self.assertEquals('from mod1 import a_func\n', mod2.read())
def test_caching_pymodule_with_syntax_errors(self):
self.project.prefs['ignore_syntax_errors'] = True
self.project.prefs['automatic_soa'] = True
self.project.pycore._init_automatic_soa()
source = 'import sys\nab cd'
mod = testutils.create_module(self.project, 'mod')
mod.write(source)
from rope.contrib import fixsyntax
fixer = fixsyntax.FixSyntax(self.project.pycore, source, mod, 10)
pymodule = fixer.get_pymodule()
self.assertTrue(pymodule.source_code.startswith('import sys\npass\n'))
def test_invalidating_cache_after_resource_change_for_init_dot_pys(self):
pkg = testutils.create_package(self.project, 'pkg')
mod = testutils.create_module(self.project, 'mod')
init_dot_py = pkg.get_child('__init__.py')
init_dot_py.write('a_var = 10\n')
mod.write('import pkg\n')
pymod = self.project.get_module('mod')
self.assertTrue('a_var' in pymod['pkg'].get_object())
init_dot_py.write('new_var = 10\n')
self.assertTrue(
'a_var' not in pymod['pkg'].get_object().get_attributes())
def test_renaming_when_unsure_with_confirmation(self):
def confirm(occurrence):
return False
code = 'class C(object):\n def a_func(self):\n pass\n' \
'def f(arg):\n arg.a_func()\n'
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write(code)
self._rename(mod1, code.index('a_func'), 'new_func', unsure=confirm)
self.assertEqual(
'class C(object):\n def new_func(self):\n pass\n'
'def f(arg):\n arg.a_func()\n', mod1.read())
def test_renaming_when_unsure_not_renaming_knowns(self):
code = 'class C1(object):\n def a_func(self):\n pass\n' \
'class C2(object):\n def a_func(self):\n pass\n' \
'c1 = C1()\nc1.a_func()\nc2 = C2()\nc2.a_func()\n'
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write(code)
self._rename(mod1, code.index('a_func'), 'new_func', unsure=self._true)
self.assertEqual(
'class C1(object):\n def new_func(self):\n pass\n'
'class C2(object):\n def a_func(self):\n pass\n'
'c1 = C1()\nc1.new_func()\nc2 = C2()\nc2.a_func()\n', mod1.read())
def test_changing_occurrs_in_the_same_module_with_conflict_ranges(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C(object):\n' \
' def create(self):\n' \
' return C()\n'
mod.write(code)
self._introduce_factory(mod, mod.read().index('C'), 'create_c', True)
expected = 'class C(object):\n' \
' def create(self):\n' \
' return create_c()\n'
self.assertTrue(mod.read().startswith(expected))
def test_adding_factory_for_global_factories(self):
code = 'class AClass(object):\n an_attr = 10\n'
mod = testutils.create_module(self.project, 'mod')
mod.write(code)
expected = 'class AClass(object):\n' \
' an_attr = 10\n\n' \
'def create(*args, **kwds):\n' \
' return AClass(*args, **kwds)\n'
self._introduce_factory(mod, mod.read().index('AClass') + 1,
'create', global_factory=True)
self.assertEqual(expected, mod.read())
def test_class_methods(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class SampleClass(object):\n' \
' def sample_method(self):\n' \
' pass\n'
mod.write(code)
mod_element = self.project.get_module('mod')
sample_class = mod_element['SampleClass'].get_object()
self.assertTrue('sample_method' in sample_class)
method = sample_class['sample_method'].get_object()
self.assertEquals(get_base_type('Function'), method.get_type())
def test_resources_parameter(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('def a_func(param):\n pass\n')
self.mod.write('import mod1\nmod1.a_func(1)\n')
signature = change_signature.ChangeSignature(
self.project, mod1,
mod1.read().index('a_func') + 1)
signature.get_changes([change_signature.ArgumentRemover(0)],
resources=[mod1]).do()
self.assertEquals('import mod1\nmod1.a_func(1)\n', self.mod.read())
self.assertEquals('def a_func():\n pass\n', mod1.read())
def test_not_leaking_for_vars_inside_parent_scope(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C(object):\n' \
' def f(self):\n' \
' for my_var1, my_var2 in []:\n' \
' pass\n'
mod.write(code)
pymod = self.pycore.resource_to_pyobject(mod)
c_class = pymod['C'].get_object()
self.assertFalse('my_var1' in c_class)
self.assertFalse('my_var2' in c_class)
def test_find_occurrences_and_class_hierarchies(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('class A(object):\n def f():\n pass\n'
'class B(A):\n def f():\n pass\n')
offset = mod1.read().rindex('f')
result1 = find_occurrences(self.project, mod1, offset)
result2 = find_occurrences(self.project,
mod1,
offset,
in_hierarchy=True)
self.assertEqual(1, len(result1))
self.assertEqual(2, len(result2))
def test_class_attributes_set_in_init_overwriting_a_defined(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C(object):\n' \
' def __init__(self):\n' \
' self.f = 20\n' \
' def f():\n' \
' pass\n'
mod.write(code)
mod_element = self.project.get_module('mod')
sample_class = mod_element['C'].get_object()
f = sample_class['f'].get_object()
self.assertTrue(isinstance(f, AbstractFunction))
def test_class_from_another_module_dti(self):
mod1 = testutils.create_module(self.project, "mod1")
mod2 = testutils.create_module(self.project, "mod2")
code1 = dedent("""\
class AClass(object):
pass
""")
code2 = dedent("""\
from mod1 import AClass
def a_func(arg):
return eval("arg")
a_var = a_func(AClass)
""")
mod1.write(code1)
mod2.write(code2)
self.pycore.run_module(mod2).wait_process()
# pymod1 = self.project.get_pymodule(mod1)
pymod2 = self.project.get_pymodule(mod2)
self.assertEqual(pymod2["AClass"].get_object(),
pymod2["a_var"].get_object())
def test_rename_in_module_renaming_one_letter_names_for_expressions(self):
mod1 = testutils.create_module(self.project, 'mod1')
mod1.write('a = 10\nprint(1+a)\n')
pymod = self.project.get_module('mod1')
old_pyname = pymod['a']
finder = rope.refactor.occurrences.create_finder(
self.project, 'a', old_pyname)
refactored = rename.rename_in_module(finder,
'new_var',
pymodule=pymod,
replace_primary=True)
self.assertEquals('new_var = 10\nprint(1+new_var)\n', refactored)
def test_changing_occurrences_in_other_modules(self):
mod1 = testutils.create_module(self.project, "mod1")
mod2 = testutils.create_module(self.project, "mod2")
mod1.write("class AClass(object):\n an_attr = 10\n")
mod2.write("import mod1\na_var = mod1.AClass()\n")
self._introduce_factory(mod1,
mod1.read().index("AClass") + 1, "create")
expected1 = dedent("""\
class AClass(object):
an_attr = 10
@staticmethod
def create(*args, **kwds):
return AClass(*args, **kwds)
""")
expected2 = dedent("""\
import mod1
a_var = mod1.AClass.create()
""")
self.assertEqual(expected1, mod1.read())
self.assertEqual(expected2, mod2.read())
def test_function_argument_dti2(self):
mod = testutils.create_module(self.project, "mod")
code = dedent("""\
def a_func(arg, a_builtin_type):
pass
a_func(a_func, [])
""")
mod.write(code)
self.pycore.run_module(mod).wait_process()
pyscope = self.project.get_pymodule(mod).get_scope()
self.assertEqual(pyscope["a_func"].get_object(),
pyscope.get_scopes()[0]["arg"].get_object())
def test_strs_and_dynamicoi(self):
mod = testutils.create_module(self.project, "mod")
code = dedent("""\
def a_func(arg):
return eval("arg")
a_var = a_func("hey")
""")
mod.write(code)
self.pycore.run_module(mod).wait_process()
pymod = self.project.get_pymodule(mod)
a_var = pymod["a_var"].get_object()
self.assertTrue(isinstance(a_var.get_type(), rope.base.builtins.Str))
def test_simple_dti(self):
mod = testutils.create_module(self.project, "mod")
code = dedent("""\
def a_func(arg):
return eval("arg")
a_var = a_func(a_func)
""")
mod.write(code)
self.pycore.run_module(mod).wait_process()
pymod = self.project.get_pymodule(mod)
self.assertEqual(pymod["a_func"].get_object(),
pymod["a_var"].get_object())
def test_trivial_find_implementations(self):
mod1 = testutils.create_module(self.project, "mod1")
mod1.write(
dedent("""\
class A(object):
def f(self):
pass
""")
)
offset = mod1.read().rindex("f(")
result = find_implementations(self.project, mod1, offset)
self.assertEqual([], result)
def test_handling_relative_imports_when_inlining(self):
pkg = testutils.create_package(self.project, "pkg")
mod3 = testutils.create_module(self.project, "mod3", pkg)
mod4 = testutils.create_module(self.project, "mod4", pkg)
mod4.write("var = 1\n")
mod3.write(
dedent("""\
from . import mod4
def f():
print(mod4.var)
"""))
self.mod.write(
dedent("""\
import pkg.mod3
pkg.mod3.f()
"""))
self._inline2(self.mod, self.mod.read().index("f(") + 1)
# Cannot determine the exact import
self.assertTrue("\n\nprint(mod4.var)\n" in self.mod.read())
def test_renaming_methods_in_sibling_classes(self):
mod = testutils.create_module(self.project, 'mod1')
mod.write('class A(object):\n def a_method(self):\n pass\n'
'class B(A):\n def a_method(self):\n pass\n'
'class C(A):\n def a_method(self):\n pass\n')
self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method',
in_hierarchy=True)
self.assertEquals(
'class A(object):\n def new_method(self):\n pass\n'
'class B(A):\n def new_method(self):\n pass\n'
'class C(A):\n def new_method(self):\n pass\n',
mod.read())
def test_import_if_necessary_in_other_mods_for_global_factories(self):
mod1 = testutils.create_module(self.project, "mod1")
mod2 = testutils.create_module(self.project, "mod2")
mod1.write("class AClass(object):\n an_attr = 10\n")
mod2.write("from mod1 import AClass\npair = AClass(), AClass\n")
self._introduce_factory(mod1,
mod1.read().index("AClass") + 1,
"create",
global_factory=True)
expected1 = dedent("""\
class AClass(object):
an_attr = 10
def create(*args, **kwds):
return AClass(*args, **kwds)
""")
expected2 = dedent("""\
from mod1 import AClass, create
pair = create(), AClass
""")
self.assertEqual(expected1, mod1.read())
self.assertEqual(expected2, mod2.read())
def test_changing_occurances_for_renamed_classes(self):
code = 'class AClass(object):\n an_attr = 10\na_class = AClass\na_var = a_class()'
mod = testutils.create_module(self.project, 'mod')
mod.write(code)
expected = 'class AClass(object):\n' \
' an_attr = 10\n\n' \
' @staticmethod\n' \
' def create(*args, **kwds):\n' \
' return AClass(*args, **kwds)\n' \
'a_class = AClass\n' \
'a_var = a_class()'
self._introduce_factory(mod, mod.read().index('a_class') + 1, 'create')
self.assertEquals(expected, mod.read())
def test_invalidating_cache_after_rsrc_chng_for_nested_init_dot_pys(self):
pkg1 = testutils.create_package(self.project, 'pkg1')
pkg2 = testutils.create_package(self.project, 'pkg2', pkg1)
mod = testutils.create_module(self.project, 'mod')
init_dot_py = pkg2.get_child('__init__.py')
init_dot_py.write('a_var = 10\n')
mod.write('import pkg1\n')
pymod = self.project.get_module('mod')
self.assertTrue(
'a_var' in pymod['pkg1'].get_object()['pkg2'].get_object())
init_dot_py.write('new_var = 10\n')
self.assertTrue(
'a_var' not in pymod['pkg1'].get_object()['pkg2'].get_object())
def test_handling_generator_functions_for_strs(self):
mod = testutils.create_module(self.project, "mod")
mod.write(
dedent("""\
def f():
yield ""
for s in f():
a_var = s
""")
)
pymod = self.project.get_pymodule(mod)
a_var = pymod["a_var"].get_object()
self.assertTrue(isinstance(a_var.get_type(), rope.base.builtins.Str))
def test_variables_defined_in_excepts(self):
mod = testutils.create_module(self.project, 'mod')
code = 'try:\n' \
' myvar1 = 1\n' \
'except:\n' \
' myvar2 = 1\n' \
'finally:\n' \
' myvar3 = 1\n'
mod.write(code)
pymod = self.pycore.resource_to_pyobject(mod)
self.assertTrue('myvar1' in pymod)
self.assertTrue('myvar2' in pymod)
self.assertTrue('myvar3' in pymod)
def test_a_function_with_different_returns(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \
'def a_func(arg):\n return eval("arg")\n' \
'a = a_func(C1())\nb = a_func(C2())\n'
mod.write(code)
self.pycore.run_module(mod).wait_process()
pymod = self.project.get_pymodule(mod)
c1_class = pymod['C1'].get_object()
c2_class = pymod['C2'].get_object()
a_var = pymod['a'].get_object()
b_var = pymod['b'].get_object()
self.assertEqual(c1_class, a_var.get_type())
self.assertEqual(c2_class, b_var.get_type())
def test_arguments_with_keywords(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \
'def a_func(arg):\n return eval("arg")\n' \
'a = a_func(arg=C1())\nb = a_func(arg=C2())\n'
mod.write(code)
self.pycore.run_module(mod).wait_process()
pymod = self.pycore.resource_to_pyobject(mod)
c1_class = pymod['C1'].get_object()
c2_class = pymod['C2'].get_object()
a_var = pymod['a'].get_object()
b_var = pymod['b'].get_object()
self.assertEquals(c1_class, a_var.get_type())
self.assertEquals(c2_class, b_var.get_type())
def test_not_saving_unknown_function_returns(self):
mod2 = testutils.create_module(self.project, 'mod2')
self.mod.write('class C(object):\n pass\nl = []\nl.append(C())\n')
mod2.write('import mod\ndef f():\n return mod.l.pop()\na_var = f()\n')
pymod = self.pycore.resource_to_pyobject(self.mod)
pymod2 = self.pycore.resource_to_pyobject(mod2)
c_class = pymod['C'].get_object()
a_var = pymod2['a_var']
self.pycore.analyze_module(mod2)
self.assertNotEquals(c_class, a_var.get_object().get_type())
self.pycore.analyze_module(self.mod)
self.assertEquals(c_class, a_var.get_object().get_type())
def test_dict_keys_and_dynamicoi2(self):
mod = testutils.create_module(self.project, 'mod')
code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \
'def a_func(arg):\n return eval("arg")\n' \
'a, b = a_func((C1(), C2()))\n'
mod.write(code)
self.pycore.run_module(mod).wait_process()
pymod = self.project.get_pymodule(mod)
c1_class = pymod['C1'].get_object()
c2_class = pymod['C2'].get_object()
a_var = pymod['a'].get_object()
b_var = pymod['b'].get_object()
self.assertEqual(c1_class, a_var.get_type())
self.assertEqual(c2_class, b_var.get_type())
def test_invalidating_data_after_changing(self):
mod = testutils.create_module(self.project, "mod")
code = dedent("""\
def a_func(arg):
return eval("arg")
a_var = a_func(a_func)
""")
mod.write(code)
self.pycore.run_module(mod).wait_process()
mod.write(code.replace("a_func", "newfunc"))
mod.write(code)
pymod = self.project.get_pymodule(mod)
self.assertNotEqual(pymod["a_func"].get_object(),
pymod["a_var"].get_object())
