Debian Codegraph @

Lib/test/test_pyrepl/test_eventqueue.py

raw
1 import tempfile
2 import unittest
3 from unittest.mock import patch
4 from test import support
5
6 from _pyrepl import terminfo
7
8 try:
9 from _pyrepl.console import Event
10 from _pyrepl import base_eventqueue
11 except ImportError:
12 pass
13
14 try:
15 from _pyrepl import unix_eventqueue
16 except ImportError:
17 pass
18
19 try:
20 from _pyrepl import windows_eventqueue
21 except ImportError:
22 pass
23
24 class EventQueueTestBase:
25 """OS-independent mixin"""
26 def make_eventqueue(self) -> base_eventqueue.BaseEventQueue:
27 raise NotImplementedError()
28
29 def test_get(self):
30 eq = self.make_eventqueue()
31 event = Event("key", "a", b"a")
32 eq.insert(event)
33 self.assertEqual(eq.get(), event)
34
35 def test_empty(self):
36 eq = self.make_eventqueue()
37 self.assertTrue(eq.empty())
38 eq.insert(Event("key", "a", b"a"))
39 self.assertFalse(eq.empty())
40
41 def test_flush_buf(self):
42 eq = self.make_eventqueue()
43 eq.buf.extend(b"test")
44 self.assertEqual(eq.flush_buf(), b"test")
45 self.assertEqual(eq.buf, bytearray())
46
47 def test_insert(self):
48 eq = self.make_eventqueue()
49 event = Event("key", "a", b"a")
50 eq.insert(event)
51 self.assertEqual(eq.events[0], event)
52
53 @patch("_pyrepl.base_eventqueue.keymap")
54 def test_push_with_key_in_keymap(self, mock_keymap):
55 mock_keymap.compile_keymap.return_value = {"a": "b"}
56 eq = self.make_eventqueue()
57 eq.keymap = {b"a": "b"}
58 eq.push(b"a")
59 mock_keymap.compile_keymap.assert_called()
60 self.assertEqual(eq.events[0].evt, "key")
61 self.assertEqual(eq.events[0].data, "b")
62
63 @patch("_pyrepl.base_eventqueue.keymap")
64 def test_push_without_key_in_keymap(self, mock_keymap):
65 mock_keymap.compile_keymap.return_value = {"a": "b"}
66 eq = self.make_eventqueue()
67 eq.keymap = {b"c": "d"}
68 eq.push(b"a")
69 mock_keymap.compile_keymap.assert_called()
70 self.assertEqual(eq.events[0].evt, "key")
71 self.assertEqual(eq.events[0].data, "a")
72
73 @patch("_pyrepl.base_eventqueue.keymap")
74 def test_push_with_keymap_in_keymap(self, mock_keymap):
75 mock_keymap.compile_keymap.return_value = {"a": "b"}
76 eq = self.make_eventqueue()
77 eq.keymap = {b"a": {b"b": "c"}}
78 eq.push(b"a")
79 mock_keymap.compile_keymap.assert_called()
80 self.assertTrue(eq.empty())
81 eq.push(b"b")
82 self.assertEqual(eq.events[0].evt, "key")
83 self.assertEqual(eq.events[0].data, "c")
84 eq.push(b"d")
85 self.assertEqual(eq.events[1].evt, "key")
86 self.assertEqual(eq.events[1].data, "d")
87
88 @patch("_pyrepl.base_eventqueue.keymap")
89 def test_push_with_keymap_in_keymap_and_escape(self, mock_keymap):
90 mock_keymap.compile_keymap.return_value = {"a": "b"}
91 eq = self.make_eventqueue()
92 eq.keymap = {b"a": {b"b": "c"}}
93 eq.push(b"a")
94 mock_keymap.compile_keymap.assert_called()
95 self.assertTrue(eq.empty())
96 eq.flush_buf()
97 eq.push(b"\033")
98 self.assertEqual(eq.events[0].evt, "key")
99 self.assertEqual(eq.events[0].data, "\033")
100 eq.push(b"b")
101 self.assertEqual(eq.events[1].evt, "key")
102 self.assertEqual(eq.events[1].data, "b")
103
104 def test_push_special_key(self):
105 eq = self.make_eventqueue()
106 eq.keymap = {}
107 eq.push(b"\x1b")
108 eq.push(b"[")
109 eq.push(b"A")
110 self.assertEqual(eq.events[0].evt, "key")
111 self.assertEqual(eq.events[0].data, "\x1b")
112
113 def test_push_unrecognized_escape_sequence(self):
114 eq = self.make_eventqueue()
115 eq.keymap = {}
116 eq.push(b"\x1b")
117 eq.push(b"[")
118 eq.push(b"Z")
119 self.assertEqual(len(eq.events), 3)
120 self.assertEqual(eq.events[0].evt, "key")
121 self.assertEqual(eq.events[0].data, "\x1b")
122 self.assertEqual(eq.events[1].evt, "key")
123 self.assertEqual(eq.events[1].data, "[")
124 self.assertEqual(eq.events[2].evt, "key")
125 self.assertEqual(eq.events[2].data, "Z")
126
127 def test_push_unicode_character_as_str(self):
128 eq = self.make_eventqueue()
129 eq.keymap = {}
130 with self.assertRaises(AssertionError):
131 eq.push("ч")
132 with self.assertRaises(AssertionError):
133 eq.push("ñ")
134
135 def test_push_unicode_character_two_bytes(self):
136 eq = self.make_eventqueue()
137 eq.keymap = {}
138
139 encoded = "ч".encode(eq.encoding, "replace")
140 self.assertEqual(len(encoded), 2)
141
142 eq.push(encoded[0])
143 e = eq.get()
144 self.assertIsNone(e)
145
146 eq.push(encoded[1])
147 e = eq.get()
148 self.assertEqual(e.evt, "key")
149 self.assertEqual(e.data, "ч")
150
151 def test_push_single_chars_and_unicode_character_as_str(self):
152 eq = self.make_eventqueue()
153 eq.keymap = {}
154
155 def _event(evt, data, raw=None):
156 r = raw if raw is not None else data.encode(eq.encoding)
157 e = Event(evt, data, r)
158 return e
159
160 def _push(keys):
161 for k in keys:
162 eq.push(k)
163
164 self.assertIsInstance("ñ", str)
165
166 # If an exception happens during push, the existing events must be
167 # preserved and we can continue to push.
168 _push(b"b")
169 with self.assertRaises(AssertionError):
170 _push("ñ")
171 _push(b"a")
172
173 self.assertEqual(eq.get(), _event("key", "b"))
174 self.assertEqual(eq.get(), _event("key", "a"))
175
176
177 class EmptyTermInfo(terminfo.TermInfo):
178 def get(self, cap: str) -> bytes:
179 return b""
180
181
182 @unittest.skipIf(support.MS_WINDOWS, "No Unix event queue on Windows")
183 class TestUnixEventQueue(EventQueueTestBase, unittest.TestCase):
184 def setUp(self):
185 self.file = tempfile.TemporaryFile()
186
187 def tearDown(self) -> None:
188 self.file.close()
189
190 def make_eventqueue(self) -> base_eventqueue.BaseEventQueue:
191 ti = EmptyTermInfo("ansi")
192 return unix_eventqueue.EventQueue(self.file.fileno(), "utf-8", ti)
193
194
195 @unittest.skipUnless(support.MS_WINDOWS, "No Windows event queue on Unix")
196 class TestWindowsEventQueue(EventQueueTestBase, unittest.TestCase):
197 def make_eventqueue(self) -> base_eventqueue.BaseEventQueue:
198 return windows_eventqueue.EventQueue("utf-8")