Debian Codegraph @

Lib/test/test_rlcompleter.py

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