Debian Codegraph @

Lib/test/test_rlcompleter.py

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