Debian Codegraph @

Lib/test/test_audit.py

raw
1 """Tests for sys.audit and sys.addaudithook
2 """
3
4 import subprocess
5 import sys
6 import unittest
7 from test import support
8 from test.support import import_helper
9 from test.support import os_helper
10
11
12 if not hasattr(sys, "addaudithook") or not hasattr(sys, "audit"):
13 raise unittest.SkipTest("test only relevant when sys.audit is available")
14
15 AUDIT_TESTS_PY = support.findfile("audit-tests.py")
16
17
18 class AuditTest(unittest.TestCase):
19 maxDiff = None
20
21 @support.requires_subprocess()
22 def run_test_in_subprocess(self, *args):
23 with subprocess.Popen(
24 [sys.executable, "-X utf8", AUDIT_TESTS_PY, *args],
25 encoding="utf-8",
26 errors="backslashreplace",
27 stdout=subprocess.PIPE,
28 stderr=subprocess.PIPE,
29 ) as p:
30 p.wait()
31 return p, p.stdout.read(), p.stderr.read()
32
33 def do_test(self, *args):
34 proc, stdout, stderr = self.run_test_in_subprocess(*args)
35
36 sys.stdout.write(stdout)
37 sys.stderr.write(stderr)
38 if proc.returncode:
39 self.fail(stderr)
40
41 def run_python(self, *args, expect_stderr=False):
42 events = []
43 proc, stdout, stderr = self.run_test_in_subprocess(*args)
44 if not expect_stderr or support.verbose:
45 sys.stderr.write(stderr)
46 return (
47 proc.returncode,
48 [line.strip().partition(" ") for line in stdout.splitlines()],
49 stderr,
50 )
51
52 def test_basic(self):
53 self.do_test("test_basic")
54
55 def test_block_add_hook(self):
56 self.do_test("test_block_add_hook")
57
58 def test_block_add_hook_baseexception(self):
59 self.do_test("test_block_add_hook_baseexception")
60
61 def test_marshal(self):
62 import_helper.import_module("marshal")
63
64 self.do_test("test_marshal")
65
66 def test_pickle(self):
67 import_helper.import_module("pickle")
68
69 self.do_test("test_pickle")
70
71 def test_monkeypatch(self):
72 self.do_test("test_monkeypatch")
73
74 def test_open(self):
75 self.do_test("test_open", os_helper.TESTFN)
76
77 def test_cantrace(self):
78 self.do_test("test_cantrace")
79
80 def test_mmap(self):
81 self.do_test("test_mmap")
82
83 def test_ctypes_call_function(self):
84 import_helper.import_module("ctypes")
85 self.do_test("test_ctypes_call_function")
86
87 def test_posixsubprocess(self):
88 import_helper.import_module("_posixsubprocess")
89 self.do_test("test_posixsubprocess")
90
91 def test_excepthook(self):
92 returncode, events, stderr = self.run_python("test_excepthook")
93 if not returncode:
94 self.fail(f"Expected fatal exception\n{stderr}")
95
96 self.assertSequenceEqual(
97 [("sys.excepthook", " ", "RuntimeError('fatal-error')")], events
98 )
99
100 def test_unraisablehook(self):
101 import_helper.import_module("_testcapi")
102 returncode, events, stderr = self.run_python("test_unraisablehook")
103 if returncode:
104 self.fail(stderr)
105
106 self.assertEqual(events[0][0], "sys.unraisablehook")
107 self.assertEqual(
108 events[0][2],
109 "RuntimeError('nonfatal-error') Exception ignored for audit hook test",
110 )
111
112 def test_winreg(self):
113 import_helper.import_module("winreg")
114 returncode, events, stderr = self.run_python("test_winreg")
115 if returncode:
116 self.fail(stderr)
117
118 self.assertEqual(events[0][0], "winreg.OpenKey")
119 self.assertEqual(events[1][0], "winreg.OpenKey/result")
120 expected = events[1][2]
121 self.assertTrue(expected)
122 self.assertSequenceEqual(["winreg.EnumKey", " ", f"{expected} 0"], events[2])
123 self.assertSequenceEqual(["winreg.EnumKey", " ", f"{expected} 10000"], events[3])
124 self.assertSequenceEqual(["winreg.PyHKEY.Detach", " ", expected], events[4])
125
126 def test_socket(self):
127 import_helper.import_module("socket")
128 returncode, events, stderr = self.run_python("test_socket")
129 if returncode:
130 self.fail(stderr)
131
132 if support.verbose:
133 print(*events, sep='\n')
134 self.assertEqual(events[0][0], "socket.gethostname")
135 self.assertEqual(events[1][0], "socket.__new__")
136 self.assertEqual(events[2][0], "socket.bind")
137 self.assertEndsWith(events[2][2], "('127.0.0.1', 8080)")
138
139 def test_gc(self):
140 returncode, events, stderr = self.run_python("test_gc")
141 if returncode:
142 self.fail(stderr)
143
144 if support.verbose:
145 print(*events, sep='\n')
146 self.assertEqual(
147 [event[0] for event in events],
148 ["gc.get_objects", "gc.get_referrers", "gc.get_referents"]
149 )
150
151
152 @support.requires_resource('network')
153 def test_http(self):
154 import_helper.import_module("http.client")
155 returncode, events, stderr = self.run_python("test_http_client")
156 if returncode:
157 self.fail(stderr)
158
159 if support.verbose:
160 print(*events, sep='\n')
161 self.assertEqual(events[0][0], "http.client.connect")
162 self.assertEqual(events[0][2], "www.python.org 80")
163 self.assertEqual(events[1][0], "http.client.send")
164 if events[1][2] != '[cannot send]':
165 self.assertIn('HTTP', events[1][2])
166
167
168 def test_sqlite3(self):
169 sqlite3 = import_helper.import_module("sqlite3")
170 returncode, events, stderr = self.run_python("test_sqlite3")
171 if returncode:
172 self.fail(stderr)
173
174 if support.verbose:
175 print(*events, sep='\n')
176 actual = [ev[0] for ev in events]
177 expected = ["sqlite3.connect", "sqlite3.connect/handle"] * 2
178
179 if hasattr(sqlite3.Connection, "enable_load_extension"):
180 expected += [
181 "sqlite3.enable_load_extension",
182 "sqlite3.load_extension",
183 ]
184 self.assertEqual(actual, expected)
185
186
187 def test_sys_getframe(self):
188 returncode, events, stderr = self.run_python("test_sys_getframe")
189 if returncode:
190 self.fail(stderr)
191
192 if support.verbose:
193 print(*events, sep='\n')
194 actual = [(ev[0], ev[2]) for ev in events]
195 expected = [("sys._getframe", "test_sys_getframe")]
196
197 self.assertEqual(actual, expected)
198
199 def test_sys_getframemodulename(self):
200 returncode, events, stderr = self.run_python("test_sys_getframemodulename")
201 if returncode:
202 self.fail(stderr)
203
204 if support.verbose:
205 print(*events, sep='\n')
206 actual = [(ev[0], ev[2]) for ev in events]
207 expected = [("sys._getframemodulename", "0")]
208
209 self.assertEqual(actual, expected)
210
211
212 def test_threading(self):
213 returncode, events, stderr = self.run_python("test_threading")
214 if returncode:
215 self.fail(stderr)
216
217 if support.verbose:
218 print(*events, sep='\n')
219 actual = [(ev[0], ev[2]) for ev in events]
220 expected = [
221 ("_thread.start_new_thread", "(<test_func>, (), None)"),
222 ("test.test_func", "()"),
223 ("_thread.start_joinable_thread", "(<test_func>, 1, None)"),
224 ("test.test_func", "()"),
225 ]
226
227 self.assertEqual(actual, expected)
228
229
230 def test_wmi_exec_query(self):
231 import_helper.import_module("_wmi")
232 returncode, events, stderr = self.run_python("test_wmi_exec_query")
233 if returncode:
234 self.fail(stderr)
235
236 if support.verbose:
237 print(*events, sep='\n')
238 actual = [(ev[0], ev[2]) for ev in events]
239 expected = [("_wmi.exec_query", "SELECT * FROM Win32_OperatingSystem")]
240
241 self.assertEqual(actual, expected)
242
243 def test_syslog(self):
244 syslog = import_helper.import_module("syslog")
245
246 returncode, events, stderr = self.run_python("test_syslog")
247 if returncode:
248 self.fail(stderr)
249
250 if support.verbose:
251 print('Events:', *events, sep='\n ')
252
253 self.assertSequenceEqual(
254 events,
255 [('syslog.openlog', ' ', f'python 0 {syslog.LOG_USER}'),
256 ('syslog.syslog', ' ', f'{syslog.LOG_INFO} test'),
257 ('syslog.setlogmask', ' ', f'{syslog.LOG_DEBUG}'),
258 ('syslog.closelog', '', ''),
259 ('syslog.syslog', ' ', f'{syslog.LOG_INFO} test2'),
260 ('syslog.openlog', ' ', f'audit-tests.py 0 {syslog.LOG_USER}'),
261 ('syslog.openlog', ' ', f'audit-tests.py {syslog.LOG_NDELAY} {syslog.LOG_LOCAL0}'),
262 ('syslog.openlog', ' ', f'None 0 {syslog.LOG_USER}'),
263 ('syslog.closelog', '', '')]
264 )
265
266 def test_not_in_gc(self):
267 returncode, _, stderr = self.run_python("test_not_in_gc")
268 if returncode:
269 self.fail(stderr)
270
271 def test_time(self):
272 returncode, events, stderr = self.run_python("test_time", "print")
273 if returncode:
274 self.fail(stderr)
275
276 if support.verbose:
277 print(*events, sep='\n')
278
279 actual = [(ev[0], ev[2]) for ev in events]
280 expected = [("time.sleep", "0"),
281 ("time.sleep", "0.0625"),
282 ("time.sleep", "-1")]
283
284 self.assertEqual(actual, expected)
285
286 def test_time_fail(self):
287 returncode, events, stderr = self.run_python("test_time", "fail",
288 expect_stderr=True)
289 self.assertNotEqual(returncode, 0)
290 self.assertIn('hook failed', stderr.splitlines()[-1])
291
292 def test_sys_monitoring_register_callback(self):
293 returncode, events, stderr = self.run_python("test_sys_monitoring_register_callback")
294 if returncode:
295 self.fail(stderr)
296
297 if support.verbose:
298 print(*events, sep='\n')
299 actual = [(ev[0], ev[2]) for ev in events]
300 expected = [("sys.monitoring.register_callback", "(None,)")]
301
302 self.assertEqual(actual, expected)
303
304 def test_winapi_createnamedpipe(self):
305 winapi = import_helper.import_module("_winapi")
306
307 pipe_name = r"\\.\pipe\LOCAL\test_winapi_createnamed_pipe"
308 returncode, events, stderr = self.run_python("test_winapi_createnamedpipe", pipe_name)
309 if returncode:
310 self.fail(stderr)
311
312 if support.verbose:
313 print(*events, sep='\n')
314 actual = [(ev[0], ev[2]) for ev in events]
315 expected = [("_winapi.CreateNamedPipe", f"({pipe_name!r}, 3, 8)")]
316
317 self.assertEqual(actual, expected)
318
319 def test_assert_unicode(self):
320 # See gh-126018
321 returncode, _, stderr = self.run_python("test_assert_unicode")
322 if returncode:
323 self.fail(stderr)
324
325 @support.support_remote_exec_only
326 @support.cpython_only
327 def test_sys_remote_exec(self):
328 returncode, events, stderr = self.run_python("test_sys_remote_exec")
329 self.assertTrue(any(["sys.remote_exec" in event for event in events]))
330 self.assertTrue(any(["cpython.remote_debugger_script" in event for event in events]))
331 if returncode:
332 self.fail(stderr)
333
334 if __name__ == "__main__":
335 unittest.main()