Debian Codegraph @

Lib/test/test_pathlib/test_read.py

raw
1 """
2 Tests for pathlib.types._ReadablePath
3 """
4
5 import collections.abc
6 import io
7 import sys
8 import unittest
9
10 from .support import is_pypi
11 from .support.local_path import ReadableLocalPath, LocalPathGround
12 from .support.zip_path import ReadableZipPath, ZipPathGround
13
14 if is_pypi:
15 from pathlib_abc import PathInfo, _ReadablePath
16 from pathlib_abc._os import magic_open
17 else:
18 from pathlib.types import PathInfo, _ReadablePath
19 from pathlib._os import magic_open
20
21
22 class ReadTestBase:
23 def setUp(self):
24 self.root = self.ground.setup()
25 self.ground.create_hierarchy(self.root)
26
27 def tearDown(self):
28 self.ground.teardown(self.root)
29
30 def test_is_readable(self):
31 self.assertIsInstance(self.root, _ReadablePath)
32
33 def test_open_r(self):
34 p = self.root / 'fileA'
35 with magic_open(p, 'r', encoding='utf-8') as f:
36 self.assertIsInstance(f, io.TextIOBase)
37 self.assertEqual(f.read(), 'this is file A\n')
38
39 @unittest.skipIf(
40 not getattr(sys.flags, 'warn_default_encoding', 0),
41 "Requires warn_default_encoding",
42 )
43 def test_open_r_encoding_warning(self):
44 p = self.root / 'fileA'
45 with self.assertWarns(EncodingWarning) as wc:
46 with magic_open(p, 'r'):
47 pass
48 self.assertEqual(wc.filename, __file__)
49
50 def test_open_rb(self):
51 p = self.root / 'fileA'
52 with magic_open(p, 'rb') as f:
53 self.assertEqual(f.read(), b'this is file A\n')
54 self.assertRaises(ValueError, magic_open, p, 'rb', encoding='utf8')
55 self.assertRaises(ValueError, magic_open, p, 'rb', errors='strict')
56 self.assertRaises(ValueError, magic_open, p, 'rb', newline='')
57
58 def test_read_bytes(self):
59 p = self.root / 'fileA'
60 self.assertEqual(p.read_bytes(), b'this is file A\n')
61
62 def test_read_text(self):
63 p = self.root / 'fileA'
64 self.assertEqual(p.read_text(encoding='utf-8'), 'this is file A\n')
65 q = self.root / 'abc'
66 self.ground.create_file(q, b'\xe4bcdefg')
67 self.assertEqual(q.read_text(encoding='latin-1'), 'äbcdefg')
68 self.assertEqual(q.read_text(encoding='utf-8', errors='ignore'), 'bcdefg')
69
70 @unittest.skipIf(
71 not getattr(sys.flags, 'warn_default_encoding', 0),
72 "Requires warn_default_encoding",
73 )
74 def test_read_text_encoding_warning(self):
75 p = self.root / 'fileA'
76 with self.assertWarns(EncodingWarning) as wc:
77 p.read_text()
78 self.assertEqual(wc.filename, __file__)
79
80 def test_read_text_with_newlines(self):
81 p = self.root / 'abc'
82 self.ground.create_file(p, b'abcde\r\nfghlk\n\rmnopq')
83 # Check that `\n` character change nothing
84 self.assertEqual(p.read_text(encoding='utf-8', newline='\n'), 'abcde\r\nfghlk\n\rmnopq')
85 # Check that `\r` character replaces `\n`
86 self.assertEqual(p.read_text(encoding='utf-8', newline='\r'), 'abcde\r\nfghlk\n\rmnopq')
87 # Check that `\r\n` character replaces `\n`
88 self.assertEqual(p.read_text(encoding='utf-8', newline='\r\n'), 'abcde\r\nfghlk\n\rmnopq')
89
90 def test_iterdir(self):
91 expected = ['dirA', 'dirB', 'dirC', 'fileA']
92 if self.ground.can_symlink:
93 expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
94 expected = {self.root.joinpath(name) for name in expected}
95 actual = set(self.root.iterdir())
96 self.assertEqual(actual, expected)
97
98 def test_iterdir_nodir(self):
99 p = self.root / 'fileA'
100 self.assertRaises(OSError, p.iterdir)
101
102 def test_iterdir_info(self):
103 for child in self.root.iterdir():
104 self.assertIsInstance(child.info, PathInfo)
105 self.assertTrue(child.info.exists(follow_symlinks=False))
106
107 def test_glob(self):
108 if not self.ground.can_symlink:
109 self.skipTest("requires symlinks")
110
111 p = self.root
112 sep = self.root.parser.sep
113 altsep = self.root.parser.altsep
114 def check(pattern, expected):
115 if altsep:
116 expected = {name.replace(altsep, sep) for name in expected}
117 expected = {p.joinpath(name) for name in expected}
118 actual = set(p.glob(pattern, recurse_symlinks=True))
119 self.assertEqual(actual, expected)
120
121 it = p.glob("fileA")
122 self.assertIsInstance(it, collections.abc.Iterator)
123 self.assertEqual(list(it), [p.joinpath("fileA")])
124 check("*A", ["dirA", "fileA", "linkA"])
125 check("*A", ['dirA', 'fileA', 'linkA'])
126 check("*B/*", ["dirB/fileB", "linkB/fileB"])
127 check("*B/*", ['dirB/fileB', 'linkB/fileB'])
128 check("brokenLink", ['brokenLink'])
129 check("brokenLinkLoop", ['brokenLinkLoop'])
130 check("**/", ["", "dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/", "linkB/"])
131 check("**/*/", ["dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/", "linkB/"])
132 check("*/", ["dirA/", "dirB/", "dirC/", "linkB/"])
133 check("*/dirD/**/", ["dirC/dirD/"])
134 check("*/dirD/**", ["dirC/dirD/", "dirC/dirD/fileD"])
135 check("dir*/**", ["dirA/", "dirA/linkC", "dirA/linkC/fileB", "dirB/", "dirB/fileB", "dirC/",
136 "dirC/fileC", "dirC/dirD", "dirC/dirD/fileD", "dirC/novel.txt"])
137 check("dir*/**/", ["dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/"])
138 check("dir*/**/..", ["dirA/..", "dirA/linkC/..", "dirB/..", "dirC/..", "dirC/dirD/.."])
139 check("dir*/*/**", ["dirA/linkC/", "dirA/linkC/fileB", "dirC/dirD/", "dirC/dirD/fileD"])
140 check("dir*/*/**/", ["dirA/linkC/", "dirC/dirD/"])
141 check("dir*/*/**/..", ["dirA/linkC/..", "dirC/dirD/.."])
142 check("dir*/*/..", ["dirC/dirD/..", "dirA/linkC/.."])
143 check("dir*/*/../dirD/**/", ["dirC/dirD/../dirD/"])
144 check("dir*/**/fileC", ["dirC/fileC"])
145 check("dir*/file*", ["dirB/fileB", "dirC/fileC"])
146 check("**/*/fileA", [])
147 check("fileB", [])
148 check("**/*/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB"])
149 check("**/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB"])
150 check("*/fileB", ["dirB/fileB", "linkB/fileB"])
151 check("*/fileB", ['dirB/fileB', 'linkB/fileB'])
152 check("**/file*",
153 ["fileA", "dirA/linkC/fileB", "dirB/fileB", "dirC/fileC", "dirC/dirD/fileD",
154 "linkB/fileB"])
155 with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
156 list(p.glob(''))
157
158 def test_walk_top_down(self):
159 it = self.root.walk()
160
161 path, dirnames, filenames = next(it)
162 dirnames.sort()
163 filenames.sort()
164 self.assertEqual(path, self.root)
165 self.assertEqual(dirnames, ['dirA', 'dirB', 'dirC'])
166 self.assertEqual(filenames, ['brokenLink', 'brokenLinkLoop', 'fileA', 'linkA', 'linkB']
167 if self.ground.can_symlink else ['fileA'])
168
169 path, dirnames, filenames = next(it)
170 self.assertEqual(path, self.root / 'dirA')
171 self.assertEqual(dirnames, [])
172 self.assertEqual(filenames, ['linkC'] if self.ground.can_symlink else [])
173
174 path, dirnames, filenames = next(it)
175 self.assertEqual(path, self.root / 'dirB')
176 self.assertEqual(dirnames, [])
177 self.assertEqual(filenames, ['fileB'])
178
179 path, dirnames, filenames = next(it)
180 filenames.sort()
181 self.assertEqual(path, self.root / 'dirC')
182 self.assertEqual(dirnames, ['dirD'])
183 self.assertEqual(filenames, ['fileC', 'novel.txt'])
184
185 path, dirnames, filenames = next(it)
186 self.assertEqual(path, self.root / 'dirC' / 'dirD')
187 self.assertEqual(dirnames, [])
188 self.assertEqual(filenames, ['fileD'])
189
190 self.assertRaises(StopIteration, next, it)
191
192 def test_walk_prune(self):
193 expected = {self.root, self.root / 'dirA', self.root / 'dirC', self.root / 'dirC' / 'dirD'}
194 actual = set()
195 for path, dirnames, filenames in self.root.walk():
196 actual.add(path)
197 if path == self.root:
198 dirnames.remove('dirB')
199 self.assertEqual(actual, expected)
200
201 def test_walk_bottom_up(self):
202 seen_root = seen_dira = seen_dirb = seen_dirc = seen_dird = False
203 for path, dirnames, filenames in self.root.walk(top_down=False):
204 if path == self.root:
205 self.assertFalse(seen_root)
206 self.assertTrue(seen_dira)
207 self.assertTrue(seen_dirb)
208 self.assertTrue(seen_dirc)
209 self.assertEqual(sorted(dirnames), ['dirA', 'dirB', 'dirC'])
210 self.assertEqual(sorted(filenames),
211 ['brokenLink', 'brokenLinkLoop', 'fileA', 'linkA', 'linkB']
212 if self.ground.can_symlink else ['fileA'])
213 seen_root = True
214 elif path == self.root / 'dirA':
215 self.assertFalse(seen_root)
216 self.assertFalse(seen_dira)
217 self.assertEqual(dirnames, [])
218 self.assertEqual(filenames, ['linkC'] if self.ground.can_symlink else [])
219 seen_dira = True
220 elif path == self.root / 'dirB':
221 self.assertFalse(seen_root)
222 self.assertFalse(seen_dirb)
223 self.assertEqual(dirnames, [])
224 self.assertEqual(filenames, ['fileB'])
225 seen_dirb = True
226 elif path == self.root / 'dirC':
227 self.assertFalse(seen_root)
228 self.assertFalse(seen_dirc)
229 self.assertTrue(seen_dird)
230 self.assertEqual(dirnames, ['dirD'])
231 self.assertEqual(sorted(filenames), ['fileC', 'novel.txt'])
232 seen_dirc = True
233 elif path == self.root / 'dirC' / 'dirD':
234 self.assertFalse(seen_root)
235 self.assertFalse(seen_dirc)
236 self.assertFalse(seen_dird)
237 self.assertEqual(dirnames, [])
238 self.assertEqual(filenames, ['fileD'])
239 seen_dird = True
240 else:
241 raise AssertionError(f"Unexpected path: {path}")
242 self.assertTrue(seen_root)
243
244 def test_info_exists(self):
245 p = self.root
246 self.assertTrue(p.info.exists())
247 self.assertTrue((p / 'dirA').info.exists())
248 self.assertTrue((p / 'dirA').info.exists(follow_symlinks=False))
249 self.assertTrue((p / 'fileA').info.exists())
250 self.assertTrue((p / 'fileA').info.exists(follow_symlinks=False))
251 self.assertFalse((p / 'non-existing').info.exists())
252 self.assertFalse((p / 'non-existing').info.exists(follow_symlinks=False))
253 if self.ground.can_symlink:
254 self.assertTrue((p / 'linkA').info.exists())
255 self.assertTrue((p / 'linkA').info.exists(follow_symlinks=False))
256 self.assertTrue((p / 'linkB').info.exists())
257 self.assertTrue((p / 'linkB').info.exists(follow_symlinks=True))
258 self.assertFalse((p / 'brokenLink').info.exists())
259 self.assertTrue((p / 'brokenLink').info.exists(follow_symlinks=False))
260 self.assertFalse((p / 'brokenLinkLoop').info.exists())
261 self.assertTrue((p / 'brokenLinkLoop').info.exists(follow_symlinks=False))
262 self.assertFalse((p / 'fileA\udfff').info.exists())
263 self.assertFalse((p / 'fileA\udfff').info.exists(follow_symlinks=False))
264 self.assertFalse((p / 'fileA\x00').info.exists())
265 self.assertFalse((p / 'fileA\x00').info.exists(follow_symlinks=False))
266
267 def test_info_is_dir(self):
268 p = self.root
269 self.assertTrue((p / 'dirA').info.is_dir())
270 self.assertTrue((p / 'dirA').info.is_dir(follow_symlinks=False))
271 self.assertFalse((p / 'fileA').info.is_dir())
272 self.assertFalse((p / 'fileA').info.is_dir(follow_symlinks=False))
273 self.assertFalse((p / 'non-existing').info.is_dir())
274 self.assertFalse((p / 'non-existing').info.is_dir(follow_symlinks=False))
275 if self.ground.can_symlink:
276 self.assertFalse((p / 'linkA').info.is_dir())
277 self.assertFalse((p / 'linkA').info.is_dir(follow_symlinks=False))
278 self.assertTrue((p / 'linkB').info.is_dir())
279 self.assertFalse((p / 'linkB').info.is_dir(follow_symlinks=False))
280 self.assertFalse((p / 'brokenLink').info.is_dir())
281 self.assertFalse((p / 'brokenLink').info.is_dir(follow_symlinks=False))
282 self.assertFalse((p / 'brokenLinkLoop').info.is_dir())
283 self.assertFalse((p / 'brokenLinkLoop').info.is_dir(follow_symlinks=False))
284 self.assertFalse((p / 'dirA\udfff').info.is_dir())
285 self.assertFalse((p / 'dirA\udfff').info.is_dir(follow_symlinks=False))
286 self.assertFalse((p / 'dirA\x00').info.is_dir())
287 self.assertFalse((p / 'dirA\x00').info.is_dir(follow_symlinks=False))
288
289 def test_info_is_file(self):
290 p = self.root
291 self.assertTrue((p / 'fileA').info.is_file())
292 self.assertTrue((p / 'fileA').info.is_file(follow_symlinks=False))
293 self.assertFalse((p / 'dirA').info.is_file())
294 self.assertFalse((p / 'dirA').info.is_file(follow_symlinks=False))
295 self.assertFalse((p / 'non-existing').info.is_file())
296 self.assertFalse((p / 'non-existing').info.is_file(follow_symlinks=False))
297 if self.ground.can_symlink:
298 self.assertTrue((p / 'linkA').info.is_file())
299 self.assertFalse((p / 'linkA').info.is_file(follow_symlinks=False))
300 self.assertFalse((p / 'linkB').info.is_file())
301 self.assertFalse((p / 'linkB').info.is_file(follow_symlinks=False))
302 self.assertFalse((p / 'brokenLink').info.is_file())
303 self.assertFalse((p / 'brokenLink').info.is_file(follow_symlinks=False))
304 self.assertFalse((p / 'brokenLinkLoop').info.is_file())
305 self.assertFalse((p / 'brokenLinkLoop').info.is_file(follow_symlinks=False))
306 self.assertFalse((p / 'fileA\udfff').info.is_file())
307 self.assertFalse((p / 'fileA\udfff').info.is_file(follow_symlinks=False))
308 self.assertFalse((p / 'fileA\x00').info.is_file())
309 self.assertFalse((p / 'fileA\x00').info.is_file(follow_symlinks=False))
310
311 def test_info_is_symlink(self):
312 p = self.root
313 self.assertFalse((p / 'fileA').info.is_symlink())
314 self.assertFalse((p / 'dirA').info.is_symlink())
315 self.assertFalse((p / 'non-existing').info.is_symlink())
316 if self.ground.can_symlink:
317 self.assertTrue((p / 'linkA').info.is_symlink())
318 self.assertTrue((p / 'linkB').info.is_symlink())
319 self.assertTrue((p / 'brokenLink').info.is_symlink())
320 self.assertFalse((p / 'linkA\udfff').info.is_symlink())
321 self.assertFalse((p / 'linkA\x00').info.is_symlink())
322 self.assertTrue((p / 'brokenLinkLoop').info.is_symlink())
323 self.assertFalse((p / 'fileA\udfff').info.is_symlink())
324 self.assertFalse((p / 'fileA\x00').info.is_symlink())
325
326
327 class ZipPathReadTest(ReadTestBase, unittest.TestCase):
328 ground = ZipPathGround(ReadableZipPath)
329
330
331 class LocalPathReadTest(ReadTestBase, unittest.TestCase):
332 ground = LocalPathGround(ReadableLocalPath)
333
334
335 if not is_pypi:
336 from pathlib import Path
337
338 class PathReadTest(ReadTestBase, unittest.TestCase):
339 ground = LocalPathGround(Path)
340
341
342 if __name__ == "__main__":
343 unittest.main()