mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-31 14:07:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

GH-130614: pathlib ABCs: delete vestigial test_pathlib_abc module (#131215)

Browse source 
Remove the `test.test_pathlib.test_pathlib_abc` test module, which was
hollowed out in previous commits. Its few remaining tests are most relevant
to `PurePath` and `Path`, so we move them into `test_pathlib`.
This commit is contained in:
Barney Gale 2025-03-14 20:04:07 +00:00 • committed by GitHub
parent 27fc62cf4f
commit 633942e348
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 115 additions and 395 deletions
Download patch file Download diff file Expand all files Collapse all files

125
Lib/test/test_pathlib/test_pathlib.py
View file

@ -20,9 +20,6 @@ from test.support import is_emscripten, is_wasi
from test.support import infinite_recursion
from test.support import os_helper
from test.support.os_helper import TESTFN, FakePath
from test.test_pathlib import test_pathlib_abc
from test.test_pathlib.test_pathlib_abc import needs_posix, needs_windows
try:
import fcntl
except ImportError:
@ -56,7 +53,20 @@ def patch_replace(old_test):
return new_test
_tests_needing_posix = set()
_tests_needing_windows = set()
_tests_needing_symlinks = set()
def needs_posix(fn):
"""Decorator that marks a test as requiring a POSIX-flavoured path class."""
_tests_needing_posix.add(fn.__name__)
return fn
def needs_windows(fn):
"""Decorator that marks a test as requiring a Windows-flavoured path class."""
_tests_needing_windows.add(fn.__name__)
return fn
def needs_symlinks(fn):
"""Decorator that marks a test as requiring a path class that supports symlinks."""
_tests_needing_symlinks.add(fn.__name__)
@ -74,7 +84,7 @@ class UnsupportedOperationTest(unittest.TestCase):
# Tests for the pure classes.
#
class PurePathTest(test_pathlib_abc.JoinablePathTest):
class PurePathTest(unittest.TestCase):
cls = pathlib.PurePath
# Make sure any symbolic links in the base test path are resolved.
@ -96,6 +106,72 @@ class PurePathTest(test_pathlib_abc.JoinablePathTest):
],
}
def setUp(self):
name = self.id().split('.')[-1]
if name in _tests_needing_posix and self.cls.parser is not posixpath:
self.skipTest('requires POSIX-flavoured path class')
if name in _tests_needing_windows and self.cls.parser is posixpath:
self.skipTest('requires Windows-flavoured path class')
p = self.cls('a')
self.parser = p.parser
self.sep = self.parser.sep
self.altsep = self.parser.altsep
def _check_str_subclass(self, *args):
# Issue #21127: it should be possible to construct a PurePath object
# from a str subclass instance, and it then gets converted to
# a pure str object.
class StrSubclass(str):
pass
P = self.cls
p = P(*(StrSubclass(x) for x in args))
self.assertEqual(p, P(*args))
for part in p.parts:
self.assertIs(type(part), str)
def test_str_subclass_common(self):
self._check_str_subclass('')
self._check_str_subclass('.')
self._check_str_subclass('a')
self._check_str_subclass('a/b.txt')
self._check_str_subclass('/a/b.txt')
@needs_windows
def test_str_subclass_windows(self):
self._check_str_subclass('.\\a:b')
self._check_str_subclass('c:')
self._check_str_subclass('c:a')
self._check_str_subclass('c:a\\b.txt')
self._check_str_subclass('c:\\')
self._check_str_subclass('c:\\a')
self._check_str_subclass('c:\\a\\b.txt')
self._check_str_subclass('\\\\some\\share')
self._check_str_subclass('\\\\some\\share\\a')
self._check_str_subclass('\\\\some\\share\\a\\b.txt')
def _check_str(self, expected, args):
p = self.cls(*args)
self.assertEqual(str(p), expected.replace('/', self.sep))
def test_str_common(self):
# Canonicalized paths roundtrip.
for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
self._check_str(pathstr, (pathstr,))
# Other tests for str() are in test_equivalences().
@needs_windows
def test_str_windows(self):
p = self.cls('a/b/c')
self.assertEqual(str(p), 'a\\b\\c')
p = self.cls('c:/a/b/c')
self.assertEqual(str(p), 'c:\\a\\b\\c')
p = self.cls('//a/b')
self.assertEqual(str(p), '\\\\a\\b\\')
p = self.cls('//a/b/c')
self.assertEqual(str(p), '\\\\a\\b\\c')
p = self.cls('//a/b/c/d')
self.assertEqual(str(p), '\\\\a\\b\\c\\d')
def test_concrete_class(self):
if self.cls is pathlib.PurePath:
expected = pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath
@ -1032,7 +1108,7 @@ class PurePathSubclassTest(PurePathTest):
# Tests for the concrete classes.
#
class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
class PathTest(PurePathTest):
"""Tests for the FS-accessing functionalities of the Path classes."""
cls = pathlib.Path
can_symlink = os_helper.can_symlink()
@ -1042,8 +1118,6 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
if name in _tests_needing_symlinks and not self.can_symlink:
self.skipTest('requires symlinks')
super().setUp()
def createTestHierarchy(self):
os.mkdir(self.base)
os.mkdir(os.path.join(self.base, 'dirA'))
os.mkdir(os.path.join(self.base, 'dirB'))
@ -1082,6 +1156,15 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
os.chmod(os.path.join(self.base, 'dirE'), 0o777)
os_helper.rmtree(self.base)
def assertFileNotFound(self, func, *args, **kwargs):
with self.assertRaises(FileNotFoundError) as cm:
func(*args, **kwargs)
self.assertEqual(cm.exception.errno, errno.ENOENT)
def assertEqualNormCase(self, path_a, path_b):
normcase = self.parser.normcase
self.assertEqual(normcase(path_a), normcase(path_b))
def tempdir(self):
d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
dir=os.getcwd()))
@ -2747,6 +2830,24 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
expected = { P(self.base, 'linkB', q) for q in ['fileB', 'linkD'] }
self.assertEqual(paths, expected)
@needs_posix
def test_glob_posix(self):
P = self.cls
p = P(self.base)
q = p / "FILEa"
given = set(p.glob("FILEa"))
expect = {q} if q.info.exists() else set()
self.assertEqual(given, expect)
self.assertEqual(set(p.glob("FILEa*")), set())
@needs_windows
def test_glob_windows(self):
P = self.cls
p = P(self.base)
self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
def test_glob_empty_pattern(self):
p = self.cls('')
with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
@ -3335,7 +3436,7 @@ class PathTest(test_pathlib_abc.RWPathTest, PurePathTest):
P('c:/').group()
class PathWalkTest(test_pathlib_abc.ReadablePathWalkTest):
class PathWalkTest(unittest.TestCase):
cls = pathlib.Path
base = PathTest.base
can_symlink = PathTest.can_symlink
@ -3344,9 +3445,13 @@ class PathWalkTest(test_pathlib_abc.ReadablePathWalkTest):
name = self.id().split('.')[-1]
if name in _tests_needing_symlinks and not self.can_symlink:
self.skipTest('requires symlinks')
super().setUp()
self.walk_path = self.cls(self.base, "TEST1")
self.sub1_path = self.walk_path / "SUB1"
self.sub11_path = self.sub1_path / "SUB11"
self.sub2_path = self.walk_path / "SUB2"
self.link_path = self.sub2_path / "link"
self.sub2_tree = (self.sub2_path, [], ["tmp3"])
def createTestHierarchy(self):
# Build:
# TESTFN/
# TEST1/ a file kid and two directory kids

385
Lib/test/test_pathlib/test_pathlib_abc.py
View file

@ -1,385 +0,0 @@
import io
import os
import errno
import unittest
from pathlib.types import _JoinablePath, _ReadablePath, _WritablePath
import posixpath
from test.support.os_helper import TESTFN
_tests_needing_posix = set()
_tests_needing_windows = set()
def needs_posix(fn):
"""Decorator that marks a test as requiring a POSIX-flavoured path class."""
_tests_needing_posix.add(fn.__name__)
return fn
def needs_windows(fn):
"""Decorator that marks a test as requiring a Windows-flavoured path class."""
_tests_needing_windows.add(fn.__name__)
return fn
#
# Tests for the pure classes.
#
class DummyJoinablePath(_JoinablePath):
__slots__ = ('_segments',)
parser = posixpath
def __init__(self, *segments):
self._segments = segments
def __str__(self):
if self._segments:
return self.parser.join(*self._segments)
return ''
def __eq__(self, other):
if not isinstance(other, DummyJoinablePath):
return NotImplemented
return str(self) == str(other)
def __hash__(self):
return hash(str(self))
def __repr__(self):
return "{}({!r})".format(self.__class__.__name__, str(self))
def with_segments(self, *pathsegments):
return type(self)(*pathsegments)
class JoinablePathTest(unittest.TestCase):
cls = DummyJoinablePath
# Use a base path that's unrelated to any real filesystem path.
base = f'/this/path/kills/fascists/{TESTFN}'
def setUp(self):
name = self.id().split('.')[-1]
if name in _tests_needing_posix and self.cls.parser is not posixpath:
self.skipTest('requires POSIX-flavoured path class')
if name in _tests_needing_windows and self.cls.parser is posixpath:
self.skipTest('requires Windows-flavoured path class')
p = self.cls('a')
self.parser = p.parser
self.sep = self.parser.sep
self.altsep = self.parser.altsep
def _check_str_subclass(self, *args):
# Issue #21127: it should be possible to construct a PurePath object
# from a str subclass instance, and it then gets converted to
# a pure str object.
class StrSubclass(str):
pass
P = self.cls
p = P(*(StrSubclass(x) for x in args))
self.assertEqual(p, P(*args))
for part in p.parts:
self.assertIs(type(part), str)
def test_str_subclass_common(self):
self._check_str_subclass('')
self._check_str_subclass('.')
self._check_str_subclass('a')
self._check_str_subclass('a/b.txt')
self._check_str_subclass('/a/b.txt')
@needs_windows
def test_str_subclass_windows(self):
self._check_str_subclass('.\\a:b')
self._check_str_subclass('c:')
self._check_str_subclass('c:a')
self._check_str_subclass('c:a\\b.txt')
self._check_str_subclass('c:\\')
self._check_str_subclass('c:\\a')
self._check_str_subclass('c:\\a\\b.txt')
self._check_str_subclass('\\\\some\\share')
self._check_str_subclass('\\\\some\\share\\a')
self._check_str_subclass('\\\\some\\share\\a\\b.txt')
def _check_str(self, expected, args):
p = self.cls(*args)
self.assertEqual(str(p), expected.replace('/', self.sep))
def test_str_common(self):
# Canonicalized paths roundtrip.
for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
self._check_str(pathstr, (pathstr,))
# Other tests for str() are in test_equivalences().
@needs_windows
def test_str_windows(self):
p = self.cls('a/b/c')
self.assertEqual(str(p), 'a\\b\\c')
p = self.cls('c:/a/b/c')
self.assertEqual(str(p), 'c:\\a\\b\\c')
p = self.cls('//a/b')
self.assertEqual(str(p), '\\\\a\\b\\')
p = self.cls('//a/b/c')
self.assertEqual(str(p), '\\\\a\\b\\c')
p = self.cls('//a/b/c/d')
self.assertEqual(str(p), '\\\\a\\b\\c\\d')
#
# Tests for the virtual classes.
#
class DummyWritablePathIO(io.BytesIO):
"""
Used by DummyWritablePath to implement `__open_wb__()`
"""
def __init__(self, files, path):
super().__init__()
self.files = files
self.path = path
def close(self):
self.files[self.path] = self.getvalue()
super().close()
class DummyReadablePathInfo:
__slots__ = ('_is_dir', '_is_file')
def __init__(self, is_dir, is_file):
self._is_dir = is_dir
self._is_file = is_file
def exists(self, *, follow_symlinks=True):
return self._is_dir or self._is_file
def is_dir(self, *, follow_symlinks=True):
return self._is_dir
def is_file(self, *, follow_symlinks=True):
return self._is_file
def is_symlink(self):
return False
class DummyReadablePath(_ReadablePath, DummyJoinablePath):
"""
Simple implementation of DummyReadablePath that keeps files and
directories in memory.
"""
__slots__ = ('_info')
_files = {}
_directories = {}
parser = posixpath
def __init__(self, *segments):
super().__init__(*segments)
self._info = None
@property
def info(self):
if self._info is None:
path_str = str(self)
self._info = DummyReadablePathInfo(
is_dir=path_str.rstrip('/') in self._directories,
is_file=path_str in self._files)
return self._info
def __open_rb__(self, buffering=-1):
path = str(self)
if path in self._directories:
raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
elif path not in self._files:
raise FileNotFoundError(errno.ENOENT, "File not found", path)
return io.BytesIO(self._files[path])
def iterdir(self):
path = str(self).rstrip('/')
if path in self._files:
raise NotADirectoryError(errno.ENOTDIR, "Not a directory", path)
elif path in self._directories:
return iter([self / name for name in self._directories[path]])
else:
raise FileNotFoundError(errno.ENOENT, "File not found", path)
def readlink(self):
raise NotImplementedError
class DummyWritablePath(_WritablePath, DummyJoinablePath):
__slots__ = ()
def __open_wb__(self, buffering=-1):
path = str(self)
if path in self._directories:
raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
parent, name = posixpath.split(path)
if parent not in self._directories:
raise FileNotFoundError(errno.ENOENT, "File not found", parent)
self._files[path] = b''
self._directories[parent].add(name)
return DummyWritablePathIO(self._files, path)
def mkdir(self):
path = str(self)
parent = str(self.parent)
if path in self._directories:
raise FileExistsError(errno.EEXIST, "File exists", path)
try:
if self.name:
self._directories[parent].add(self.name)
self._directories[path] = set()
except KeyError:
raise FileNotFoundError(errno.ENOENT, "File not found", parent) from None
def symlink_to(self, target, target_is_directory=False):
raise NotImplementedError
class ReadablePathTest(JoinablePathTest):
"""Tests for ReadablePathTest methods that use stat(), open() and iterdir()."""
cls = DummyReadablePath
can_symlink = False
# (self.base)
# |
# |-- brokenLink -> non-existing
# |-- dirA
# | `-- linkC -> ../dirB
# |-- dirB
# | |-- fileB
# | `-- linkD -> ../dirB
# |-- dirC
# | |-- dirD
# | | `-- fileD
# | `-- fileC
# | `-- novel.txt
# |-- dirE # No permissions
# |-- fileA
# |-- linkA -> fileA
# |-- linkB -> dirB
# `-- brokenLinkLoop -> brokenLinkLoop
#
def setUp(self):
super().setUp()
self.createTestHierarchy()
def createTestHierarchy(self):
cls = self.cls
cls._files = {
f'{self.base}/fileA': b'this is file A\n',
f'{self.base}/dirB/fileB': b'this is file B\n',
f'{self.base}/dirC/fileC': b'this is file C\n',
f'{self.base}/dirC/dirD/fileD': b'this is file D\n',
f'{self.base}/dirC/novel.txt': b'this is a novel\n',
}
cls._directories = {
f'{self.base}': {'fileA', 'dirA', 'dirB', 'dirC', 'dirE'},
f'{self.base}/dirA': set(),
f'{self.base}/dirB': {'fileB'},
f'{self.base}/dirC': {'fileC', 'dirD', 'novel.txt'},
f'{self.base}/dirC/dirD': {'fileD'},
f'{self.base}/dirE': set(),
}
def tearDown(self):
cls = self.cls
cls._files.clear()
cls._directories.clear()
def tempdir(self):
path = self.cls(self.base).with_name('tmp-dirD')
path.mkdir()
return path
def assertFileNotFound(self, func, *args, **kwargs):
with self.assertRaises(FileNotFoundError) as cm:
func(*args, **kwargs)
self.assertEqual(cm.exception.errno, errno.ENOENT)
def assertEqualNormCase(self, path_a, path_b):
normcase = self.parser.normcase
self.assertEqual(normcase(path_a), normcase(path_b))
@needs_posix
def test_glob_posix(self):
P = self.cls
p = P(self.base)
q = p / "FILEa"
given = set(p.glob("FILEa"))
expect = {q} if q.info.exists() else set()
self.assertEqual(given, expect)
self.assertEqual(set(p.glob("FILEa*")), set())
@needs_windows
def test_glob_windows(self):
P = self.cls
p = P(self.base)
self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
class WritablePathTest(JoinablePathTest):
cls = DummyWritablePath
class DummyRWPath(DummyWritablePath, DummyReadablePath):
__slots__ = ()
class RWPathTest(WritablePathTest, ReadablePathTest):
cls = DummyRWPath
can_symlink = False
class ReadablePathWalkTest(unittest.TestCase):
cls = DummyReadablePath
base = ReadablePathTest.base
can_symlink = False
def setUp(self):
self.walk_path = self.cls(self.base, "TEST1")
self.sub1_path = self.walk_path / "SUB1"
self.sub11_path = self.sub1_path / "SUB11"
self.sub2_path = self.walk_path / "SUB2"
self.link_path = self.sub2_path / "link"
self.sub2_tree = (self.sub2_path, [], ["tmp3"])
self.createTestHierarchy()
def createTestHierarchy(self):
cls = self.cls
cls._files = {
f'{self.base}/TEST1/tmp1': b'this is tmp1\n',
f'{self.base}/TEST1/SUB1/tmp2': b'this is tmp2\n',
f'{self.base}/TEST1/SUB2/tmp3': b'this is tmp3\n',
f'{self.base}/TEST2/tmp4': b'this is tmp4\n',
}
cls._directories = {
f'{self.base}': {'TEST1', 'TEST2'},
f'{self.base}/TEST1': {'SUB1', 'SUB2', 'tmp1'},
f'{self.base}/TEST1/SUB1': {'SUB11', 'tmp2'},
f'{self.base}/TEST1/SUB1/SUB11': set(),
f'{self.base}/TEST1/SUB2': {'tmp3'},
f'{self.base}/TEST2': {'tmp4'},
}
def tearDown(self):
cls = self.cls
cls._files.clear()
cls._directories.clear()
if __name__ == "__main__":
unittest.main()