def testDetectModuleCompletionInitial(self):
source = dedent("""\
from Nested.Package.Mo
""")
line = "from Nested.Package.Mo"
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
1, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module='Nested.Package', showMembers=False)
self.assertEquals(options, expected)
source = dedent("""\
from Module.
""")
line = "from Module."
options = detectCompletionType('Module.py', source, 1, len(line), '', self.pysmelldict)
expected = CompletionOptions(Types.MODULE, module='Module', showMembers=False)
self.assertEquals(options, expected)
source = dedent("""\
from Mo
""")
line = "from Mo"
options = detectCompletionType('Module.py', source, 1, len(line), '', self.pysmelldict)
expected = CompletionOptions(Types.MODULE, module='Mo', showMembers=False)
self.assertEquals(options, expected)
def testDetectModuleCompletionTwo(self):
source = dedent("""\
from Nested.Package import
""")
line = "from Nested.Package import "
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
1, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module="Nested.Package", showMembers=True)
self.assertEquals(options, expected)
source = dedent("""\
from Nested import
""")
line = "from Nested import "
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
1, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module="Nested", showMembers=True)
self.assertEquals(options, expected)
source = dedent("""\
from Nested import Pack
""")
line = "from Nested import Pack"
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
1, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module="Nested", showMembers=True)
self.assertEquals(options, expected)
def testKnowAboutClassHierarchies(self):
options = CompletionOptions(
Types.INSTANCE, klass='Module.bClass',
parents=[]) #possible error - why no parents
compls = findCompletions('', self.pysmelldict, options)
expected = [
compMeth('am', 'aClass'),
compProp('aprop', 'aClass'),
compMeth('bm', 'aClass'),
compProp('bprop', 'aClass'),
compMeth('cm', 'bClass'),
compProp('cprop', 'bClass'),
compMeth('dm', 'bClass'),
compProp('dprop', 'bClass')
]
self.assertEquals(compls, expected)
options = CompletionOptions(Types.INSTANCE,
klass='Module.cClass',
parents=['Module.bClass'])
compls = findCompletions('', self.pysmelldict, options)
expected = [
compMeth('am', 'aClass'),
compProp('aprop', 'aClass'),
compMeth('bm', 'aClass'),
compProp('bprop', 'aClass'),
compMeth('cm', 'bClass'),
compProp('cprop', 'bClass'),
compMeth('dm', 'bClass'),
compProp('dprop', 'bClass')
]
self.assertEquals(compls, expected)
def testCompletions(self):
options = CompletionOptions(Types.TOPLEVEL)
compls = findCompletions('b', self.pysmelldict, options)
expected = [
compFunc('b', 'arg1, arg2'),
compClass('bClass'),
compConst('bconst')
]
self.assertEquals(compls, expected)
def testDetectCompleteArgumentListFunction(self):
source = dedent("""\
def a():
b(
""")
line = ' b('
options = detectCompletionType('path', source, 2, len(line), 'b(', self.pysmelldict)
expected = CompletionOptions(Types.FUNCTION, name='b', rindex=None)
self.assertEquals(options, expected)
def testCompleteArgumentListsProp(self):
options = CompletionOptions(Types.METHOD,
klass=None,
parents=[],
name='bm',
rindex=None)
compls = findCompletions('bm(', self.pysmelldict, options)
orig = compMeth('bm', 'aClass')
orig['word'] = orig['abbr']
self.assertEquals(compls, [orig])
def testCompleteArgumentLists(self):
options = CompletionOptions(Types.FUNCTION,
klass=None,
parents=[],
name='b',
rindex=None)
compls = findCompletions('b(', self.pysmelldict, options)
orig = compFunc('b', 'arg1, arg2')
orig['word'] = orig['abbr']
self.assertEquals(compls, [orig])
def testDetectCompleteArgumentListMethod(self):
line = 'salf.bm('
options = detectCompletionType('path', line, 1, len(line), 'bm(',
self.pysmelldict)
expected = CompletionOptions(Types.METHOD,
klass=None,
parents=[],
name='bm',
rindex=None)
self.assertEquals(options, expected)
def testDetectSimpleClass(self):
source = dedent("""\
class aClass(object):
def sth(self):
self.
""")
line = "%sself." % (' ' * 8)
options = detectCompletionType('Module.py', source, 3, len(line), '', self.pysmelldict)
expected = CompletionOptions(Types.INSTANCE, klass='Module.aClass', parents=['object'])
self.assertEquals(options, expected)
def testDetectModuleAttrLookup3(self):
source = dedent("""\
from Nested import Package
funct(Package.Module., arg)
""")
line = "funct(Package.Module."
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
3, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module="Nested.Package.Module", showMembers=True)
self.assertEquals(options, expected)
def testDetectCompleteArgumentListFunctionClosingParen(self):
source = dedent("""\
def a():
b()
""")
line = ' b()'
options = detectCompletionType('path', source, 2,
len(line) - 1, 'b(', self.pysmelldict)
expected = CompletionOptions(Types.FUNCTION, name='b',
rindex=-1) # module?
self.assertEqual(options, expected)
def testCompletionsWithPackages(self):
options = CompletionOptions(Types.INSTANCE,
klass='Nested.Package.Module.Class',
parents=[])
compls = findCompletions('', self.nestedDict, options)
expected = [
dict(word='cprop',
kind='m',
menu='Nested.Package.Module:Class',
dup='1')
]
self.assertEquals(compls, expected)
def testDetectDeepClass(self):
source = dedent("""\
class Class(object):
def sth(self):
self.
""")
line = "%sself." % (' ' * 8)
options = detectCompletionType(os.path.join('Nested', 'Package', 'Module.py'), source,
3, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.INSTANCE, klass='Nested.Package.Module.Class', parents=['object'])
self.assertEquals(options, expected)
def testCompleteWithSelfInfer(self):
options = CompletionOptions(Types.INSTANCE,
klass='Module.aClass',
parents=[])
compls = findCompletions('', self.pysmelldict, options)
expected = [
compMeth('am', 'aClass'),
compProp('aprop', 'aClass'),
compMeth('bm', 'aClass'),
compProp('bprop', 'aClass')
]
self.assertEquals(compls, expected)
def testDetectClassCreation(self):
source = dedent("""\
from Module import aClass
thing = aClass()
thing.
""")
line = "thing."
options = detectCompletionType('apath', source,
4, len(line), '', self.pysmelldict)
expected = CompletionOptions(Types.INSTANCE, klass='Module.aClass', parents=['object', 'ForeignModule.alien'])
self.assertEquals(options, expected)
def testDetectClassCreationLocal(self):
source = dedent("""\
class aClass(object):
pass
thing = aClass()
thing.
""")
line = "thing."
options = detectCompletionType(os.path.abspath('Module.py'), source,
5, len(line), '', self.pysmelldict)
expected = CompletionOptions(Types.INSTANCE, klass='Module.aClass', parents=['object'])
self.assertEquals(options, expected)
def testDetectParentsOfUnknownClass(self):
source = dedent("""\
from Nested.Package.Module import Class
class Other(Class):
def sth(self):
self.
""")
line = "%sself." % (' ' * 8)
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
4, len(line), '', NESTEDDICT, update=False)
expected = CompletionOptions(Types.INSTANCE, klass='PackageA.Module.Other', parents=['Nested.Package.Module.Class'])
self.assertEquals(options, expected)
def testDetectModuleAttrLookupWithBase2(self):
print '--------'
source = dedent("""\
from Nested.Package import Module as mod
class Some(object):
def init(self):
self.func(mod.EVT_, self.something)
""")
line = "%sself.func(mod.EVT_" % (" " * 8)
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'), source,
5, len(line), 'EVT_', NESTEDDICT, update=False)
expected = CompletionOptions(Types.MODULE, module="Nested.Package.Module", showMembers=True)
self.assertEquals(options, expected)
def testModuleCompletionThree(self):
source = dedent("""\
import Nested.Package.
""")
line = "import Nested.Package."
options = detectCompletionType(os.path.join('TestData', 'PackageA',
'Module.py'),
source,
1,
len(line),
'',
NESTEDDICT,
update=False)
expected = CompletionOptions(Types.MODULE,
module="Nested.Package",
showMembers=False)
self.assertEqual(options, expected)
source = dedent("""\
import Ne
""")
line = "import Ne"
options = detectCompletionType(os.path.join('TestData', 'PackageA',
'Module.py'),
source,
1,
len(line),
'',
NESTEDDICT,
update=False)
expected = CompletionOptions(Types.MODULE,
module="Ne",
showMembers=False)
self.assertEqual(options, expected)
def testInferShouldUpdatePYSMELLDICT(self):
source = dedent("""\
from Nested.Package.Module import Class
class FreshClass(Class):
something = 1
def sth(self):
self.
""")
line = "%sself." % (' ' * 8)
copiedDict = copy.deepcopy(self.pysmelldict)
assert copiedDict == self.pysmelldict
options = detectCompletionType(os.path.join('TestData', 'PackageA', 'Module.py'),
source, 5, len(line), '', copiedDict)
expected = CompletionOptions(Types.INSTANCE, klass='PackageA.Module.FreshClass', parents=['Nested.Package.Module.Class'])
self.assertEquals(options, expected) #sanity
klass = copiedDict['CLASSES']['PackageA.Module.FreshClass']
self.assertEquals(klass['bases'], ['Nested.Package.Module.Class'])
self.assertEquals(klass['properties'], ['something'])
self.assertEquals(klass['methods'], [('sth', [], "")])
def testDetectAttrLookup(self):
line = 'somethign.a'
options = detectCompletionType('path', line, 1, len(line), 'a',
self.pysmelldict)
expected = CompletionOptions(Types.INSTANCE, klass=None, parents=[])
self.assertEquals(options, expected)
def testDetectGlobalLookup(self):
options = detectCompletionType('path', 'b', 1, 1, 'b',
self.pysmelldict)
expected = CompletionOptions(Types.TOPLEVEL)
self.assertEquals(options, expected)
def testCompleteMembers(self):
options = CompletionOptions(Types.INSTANCE, klass=None, parents=[])
compls = findCompletions('a', self.pysmelldict, options)
expected = [compMeth('am', 'aClass'), compProp('aprop', 'aClass')]
self.assertEquals(compls, expected)
def testModuleCompletion(self):
options = CompletionOptions(Types.MODULE,
module="Ne",
showMembers=False)
expected = [dict(word='Nested', kind='t', dup='1')]
compls = findCompletions('Ne', self.nestedDict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Nested",
showMembers=False)
expected = [dict(word='Package', kind='t', dup='1')]
compls = findCompletions('P', self.nestedDict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Nested.Package",
showMembers=False)
expected = [dict(word='Module', kind='t', dup='1')]
compls = findCompletions('', self.nestedDict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Mo",
showMembers=False)
expected = [dict(word='Module', kind='t', dup='1')]
compls = findCompletions('Mo', self.pysmelldict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Module",
showMembers=False)
expected = []
compls = findCompletions('', self.pysmelldict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Nested.Package",
showMembers=True)
expected = [dict(word='Module', kind='t', dup='1')]
compls = findCompletions('', self.nestedDict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE,
module="Nested.Package.Module",
showMembers=True)
expected = [
dict(word='Class',
dup="1",
kind="t",
menu="Nested.Package.Module",
abbr="Class()"),
dict(word='Something', dup="1", kind="t"),
]
compls = findCompletions('', self.nestedDict, options)
self.assertEquals(compls, expected)
options = CompletionOptions(Types.MODULE, module="A", showMembers=True)
expected = [
dict(word='CONST_A', kind='d', dup='1', menu='A'),
dict(word='CONST_B', kind='d', dup='1', menu='B'),
dict(word='THING', kind='t', dup='1')
]
compls = findCompletions('', self.complicatedDict, options)
self.assertEquals(compls, expected)
