| 1 |
import unittest |
| 2 |
from unittest.mock import patch |
| 3 |
import builtins |
| 4 |
import rlcompleter |
| 5 |
from test.support import MISSING_C_DOCSTRINGS |
| 6 |
|
| 7 |
class CompleteMe: |
| 8 |
""" Trivial class used in testing rlcompleter.Completer. """ |
| 9 |
spam = 1 |
| 10 |
_ham = 2 |
| 11 |
|
| 12 |
|
| 13 |
class TestRlcompleter(unittest.TestCase): |
| 14 |
def setUp(self): |
| 15 |
self.stdcompleter = rlcompleter.Completer() |
| 16 |
self.completer = rlcompleter.Completer(dict(spam=int, |
| 17 |
egg=str, |
| 18 |
CompleteMe=CompleteMe)) |
| 19 |
|
| 20 |
# forces stdcompleter to bind builtins namespace |
| 21 |
self.stdcompleter.complete('', 0) |
| 22 |
|
| 23 |
def test_namespace(self): |
| 24 |
class A(dict): |
| 25 |
pass |
| 26 |
class B(list): |
| 27 |
pass |
| 28 |
|
| 29 |
self.assertTrue(self.stdcompleter.use_main_ns) |
| 30 |
self.assertFalse(self.completer.use_main_ns) |
| 31 |
self.assertFalse(rlcompleter.Completer(A()).use_main_ns) |
| 32 |
self.assertRaises(TypeError, rlcompleter.Completer, B((1,))) |
| 33 |
|
| 34 |
def test_global_matches(self): |
| 35 |
# test with builtins namespace |
| 36 |
self.assertEqual(sorted(self.stdcompleter.global_matches('di')), |
| 37 |
[x+'(' for x in dir(builtins) if x.startswith('di')]) |
| 38 |
self.assertEqual(sorted(self.stdcompleter.global_matches('st')), |
| 39 |
[x+'(' for x in dir(builtins) if x.startswith('st')]) |
| 40 |
self.assertEqual(self.stdcompleter.global_matches('akaksajadhak'), []) |
| 41 |
|
| 42 |
# test with a customized namespace |
| 43 |
self.assertEqual(self.completer.global_matches('CompleteM'), |
| 44 |
['CompleteMe(' if MISSING_C_DOCSTRINGS else 'CompleteMe()']) |
| 45 |
self.assertEqual(self.completer.global_matches('eg'), |
| 46 |
['egg(']) |
| 47 |
# XXX: see issue5256 |
| 48 |
self.assertEqual(self.completer.global_matches('CompleteM'), |
| 49 |
['CompleteMe(' if MISSING_C_DOCSTRINGS else 'CompleteMe()']) |
| 50 |
|
| 51 |
def test_attr_matches(self): |
| 52 |
# test with builtins namespace |
| 53 |
self.assertEqual(self.stdcompleter.attr_matches('str.s'), |
| 54 |
['str.{}('.format(x) for x in dir(str) |
| 55 |
if x.startswith('s')]) |
| 56 |
self.assertEqual(self.stdcompleter.attr_matches('tuple.foospamegg'), []) |
| 57 |
|
| 58 |
def create_expected_for_none(): |
| 59 |
if not MISSING_C_DOCSTRINGS: |
| 60 |
parentheses = ('__init_subclass__', '__class__') |
| 61 |
else: |
| 62 |
# When `--without-doc-strings` is used, `__class__` |
| 63 |
# won't have a known signature. |
| 64 |
parentheses = ('__init_subclass__',) |
| 65 |
|
| 66 |
items = set() |
| 67 |
for x in dir(None): |
| 68 |
if x in parentheses: |
| 69 |
items.add(f'None.{x}()') |
| 70 |
elif x == '__doc__': |
| 71 |
items.add(f'None.{x}') |
| 72 |
else: |
| 73 |
items.add(f'None.{x}(') |
| 74 |
return sorted(items) |
| 75 |
|
| 76 |
expected = create_expected_for_none() |
| 77 |
self.assertEqual(self.stdcompleter.attr_matches('None.'), expected) |
| 78 |
self.assertEqual(self.stdcompleter.attr_matches('None._'), expected) |
| 79 |
self.assertEqual(self.stdcompleter.attr_matches('None.__'), expected) |
| 80 |
|
| 81 |
# test with a customized namespace |
| 82 |
self.assertEqual(self.completer.attr_matches('CompleteMe.sp'), |
| 83 |
['CompleteMe.spam']) |
| 84 |
self.assertEqual(self.completer.attr_matches('Completeme.egg'), []) |
| 85 |
self.assertEqual(self.completer.attr_matches('CompleteMe.'), |
| 86 |
['CompleteMe.mro()', 'CompleteMe.spam']) |
| 87 |
self.assertEqual(self.completer.attr_matches('CompleteMe._'), |
| 88 |
['CompleteMe._ham']) |
| 89 |
matches = self.completer.attr_matches('CompleteMe.__') |
| 90 |
for x in matches: |
| 91 |
self.assertStartsWith(x, 'CompleteMe.__') |
| 92 |
self.assertIn('CompleteMe.__name__', matches) |
| 93 |
self.assertIn('CompleteMe.__new__(', matches) |
| 94 |
|
| 95 |
with patch.object(CompleteMe, "me", CompleteMe, create=True): |
| 96 |
self.assertEqual(self.completer.attr_matches('CompleteMe.me.me.sp'), |
| 97 |
['CompleteMe.me.me.spam']) |
| 98 |
self.assertEqual(self.completer.attr_matches('egg.s'), |
| 99 |
['egg.{}('.format(x) for x in dir(str) |
| 100 |
if x.startswith('s')]) |
| 101 |
|
| 102 |
def test_excessive_getattr(self): |
| 103 |
"""Ensure getattr() is invoked no more than once per attribute""" |
| 104 |
|
| 105 |
# note the special case for @property methods below; that is why |
| 106 |
# we use __dir__ and __getattr__ in class Foo to create a "magic" |
| 107 |
# class attribute 'bar'. This forces `getattr` to call __getattr__ |
| 108 |
# (which is doesn't necessarily do). |
| 109 |
class Foo: |
| 110 |
calls = 0 |
| 111 |
bar = '' |
| 112 |
def __getattribute__(self, name): |
| 113 |
if name == 'bar': |
| 114 |
self.calls += 1 |
| 115 |
return None |
| 116 |
return super().__getattribute__(name) |
| 117 |
|
| 118 |
f = Foo() |
| 119 |
completer = rlcompleter.Completer(dict(f=f)) |
| 120 |
self.assertEqual(completer.complete('f.b', 0), 'f.bar') |
| 121 |
self.assertEqual(f.calls, 1) |
| 122 |
|
| 123 |
def test_property_method_not_called(self): |
| 124 |
class Foo: |
| 125 |
_bar = 0 |
| 126 |
property_called = False |
| 127 |
|
| 128 |
@property |
| 129 |
def bar(self): |
| 130 |
self.property_called = True |
| 131 |
return self._bar |
| 132 |
|
| 133 |
f = Foo() |
| 134 |
completer = rlcompleter.Completer(dict(f=f)) |
| 135 |
self.assertEqual(completer.complete('f.b', 0), 'f.bar') |
| 136 |
self.assertFalse(f.property_called) |
| 137 |
|
| 138 |
|
| 139 |
def test_uncreated_attr(self): |
| 140 |
# Attributes like properties and slots should be completed even when |
| 141 |
# they haven't been created on an instance |
| 142 |
class Foo: |
| 143 |
__slots__ = ("bar",) |
| 144 |
completer = rlcompleter.Completer(dict(f=Foo())) |
| 145 |
self.assertEqual(completer.complete('f.', 0), 'f.bar') |
| 146 |
|
| 147 |
@unittest.mock.patch('rlcompleter._readline_available', False) |
| 148 |
def test_complete(self): |
| 149 |
completer = rlcompleter.Completer() |
| 150 |
self.assertEqual(completer.complete('', 0), '\t') |
| 151 |
self.assertEqual(completer.complete('a', 0), 'and ') |
| 152 |
self.assertEqual(completer.complete('a', 1), 'as ') |
| 153 |
self.assertEqual(completer.complete('as', 2), 'assert ') |
| 154 |
self.assertEqual(completer.complete('an', 0), 'and ') |
| 155 |
self.assertEqual(completer.complete('pa', 0), 'pass') |
| 156 |
self.assertEqual(completer.complete('Fa', 0), 'False') |
| 157 |
self.assertEqual(completer.complete('el', 0), 'elif ') |
| 158 |
self.assertEqual(completer.complete('el', 1), 'else') |
| 159 |
self.assertEqual(completer.complete('tr', 0), 'try:') |
| 160 |
self.assertEqual(completer.complete('_', 0), '_') |
| 161 |
self.assertEqual(completer.complete('match', 0), 'match ') |
| 162 |
self.assertEqual(completer.complete('case', 0), 'case ') |
| 163 |
|
| 164 |
def test_duplicate_globals(self): |
| 165 |
namespace = { |
| 166 |
'False': None, # Keyword vs builtin vs namespace |
| 167 |
'assert': None, # Keyword vs namespace |
| 168 |
'try': lambda: None, # Keyword vs callable |
| 169 |
'memoryview': None, # Callable builtin vs non-callable |
| 170 |
'Ellipsis': lambda: None, # Non-callable builtin vs callable |
| 171 |
} |
| 172 |
completer = rlcompleter.Completer(namespace) |
| 173 |
self.assertEqual(completer.complete('False', 0), 'False') |
| 174 |
self.assertIsNone(completer.complete('False', 1)) # No duplicates |
| 175 |
# Space or colon added due to being a reserved keyword |
| 176 |
self.assertEqual(completer.complete('assert', 0), 'assert ') |
| 177 |
self.assertIsNone(completer.complete('assert', 1)) |
| 178 |
self.assertEqual(completer.complete('try', 0), 'try:') |
| 179 |
self.assertIsNone(completer.complete('try', 1)) |
| 180 |
# No opening bracket "(" because we overrode the built-in class |
| 181 |
self.assertEqual(completer.complete('memoryview', 0), 'memoryview') |
| 182 |
self.assertIsNone(completer.complete('memoryview', 1)) |
| 183 |
self.assertEqual(completer.complete('Ellipsis', 0), 'Ellipsis()') |
| 184 |
self.assertIsNone(completer.complete('Ellipsis', 1)) |
| 185 |
|
| 186 |
if __name__ == '__main__': |
| 187 |
unittest.main() |