[bumpversion]
-current_version = 63.3.0
+current_version = 63.4.0
commit = True
tag = True
+v63.4.0
+-------
+
+
+Changes
+^^^^^^^
+* #2971: ``upload_docs`` command is deprecated once again.
+* #3475: Merge with pypa/distutils@129480b, including substantial delinting and cleanup, some refactoring around compiler logic, better messaging in cygwincompiler (pypa/distutils#161).
+
+Documentation changes
+^^^^^^^^^^^^^^^^^^^^^
+* #3443: Installed ``sphinx-hoverxref`` extension to show tooltips on internal an external references.
+ -- by :user:`humitos`
+* #3444: Installed ``sphinx-notfound-page`` extension to generate nice 404 pages.
+ -- by :user:`humitos`
+
+Misc
+^^^^
+* #3480: Merge with pypa/distutils@c397f4c
+
+
v63.3.0
-------
+++ /dev/null
-Merge with pypa/distutils@129480b, including substantial delinting and cleanup, some refactoring around compiler logic, better messaging in cygwincompiler (pypa/distutils#161).
),
})
+# Support tooltips on references
+extensions += ['hoverxref.extension']
+hoverxref_auto_ref = True
+hoverxref_intersphinx = [
+ 'python',
+ 'pip',
+ 'build',
+ 'PyPUG',
+ 'packaging',
+ 'twine',
+ 'importlib-resources',
+]
+
# Add support for linking usernames
github_url = 'https://github.com'
github_repo_org = 'pypa'
extensions += ['sphinx-favicon']
html_static_path = ['images'] # should contain the folder with icons
+# Add support for nice Not Found 404 pages
+extensions += ['notfound.extension']
+
# List of dicts with <link> HTML attributes
# static-file points to files in the html_static_path (href is computed)
favicons = [
[metadata]
name = setuptools
-version = 63.3.0
+version = 63.4.0
author = Python Packaging Authority
author_email = distutils-sig@python.org
description = Easily download, build, install, upgrade, and uninstall Python packages
jaraco.packaging >= 9
rst.linker >= 1.9
jaraco.tidelift >= 1.4
+ sphinx-notfound-page == 0.8.3
+ sphinx-hoverxref < 2
# local
pygments-github-lexers==0.0.5
try:
out = subprocess.check_output(
- 'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
+ f'cmd /u /c "{vcvarsall}" {plat_spec} && set',
stderr=subprocess.STDOUT,
).decode('utf-16le', errors='replace')
except subprocess.CalledProcessError as exc:
log.error(exc.output)
- raise DistutilsPlatformError("Error executing {}".format(exc.cmd))
+ raise DistutilsPlatformError(f"Error executing {exc.cmd}")
env = {
key.lower(): value
# sanity check for platforms to prevent obscure errors later.
if plat_name not in PLAT_TO_VCVARS:
raise DistutilsPlatformError(
- "--plat-name must be one of {}".format(tuple(PLAT_TO_VCVARS))
+ f"--plat-name must be one of {tuple(PLAT_TO_VCVARS)}"
)
# Get the vcvarsall.bat spec for the requested platform.
# Better to raise an exception instead of silently continuing
# and later complain about sources and targets having
# different lengths
- raise CompileError("Don't know how to compile {}".format(p))
+ raise CompileError(f"Don't know how to compile {p}")
return list(map(make_out_path, source_filenames))
continue
else:
# how to handle this file?
- raise CompileError(
- "Don't know how to compile {} to {}".format(src, obj)
- )
+ raise CompileError(f"Don't know how to compile {src} to {obj}")
args = [self.cc] + compile_opts + pp_opts
if add_cpp_opts:
def_file = os.path.join(temp_dir, '%s.def' % modname)
contents = ['EXPORTS']
for sym in export_symbols or []:
- contents.append(' %s=_%s' % (sym, sym))
+ contents.append(' {}=_{}'.format(sym, sym))
self.execute(write_file, (def_file, contents), "writing %s" % def_file)
# Borland C++ has problems with '/' in paths
(base, ext) = os.path.splitext(os.path.normcase(src_name))
if ext not in (self.src_extensions + ['.rc', '.res']):
raise UnknownFileError(
- "unknown file type '%s' (from '%s')" % (ext, src_name)
+ "unknown file type '{}' (from '{}')".format(ext, src_name)
)
if strip_dir:
base = os.path.basename(base)
base = base[os.path.isabs(base) :] # If abs, chop off leading /
if ext not in self.src_extensions:
raise UnknownFileError(
- "unknown file type '%s' (from '%s')" % (ext, src_name)
+ "unknown file type '{}' (from '{}')".format(ext, src_name)
)
if strip_dir:
base = os.path.basename(base)
if option[-1] == "=":
option = option[:-1]
value = getattr(self, option)
- self.announce(indent + "%s = %s" % (option, value), level=log.INFO)
+ self.announce(indent + "{} = {}".format(option, value), level=log.INFO)
def run(self):
"""A command's raison d'etre: carry out the action it exists to
return default
elif not isinstance(val, str):
raise DistutilsOptionError(
- "'%s' must be a %s (got `%s`)" % (option, what, val)
+ "'{}' must be a {} (got `{}`)".format(option, what, val)
)
return val
ok = False
if not ok:
raise DistutilsOptionError(
- "'%s' must be a list of strings (got %r)" % (option, val)
+ "'{}' must be a list of strings (got {!r})".format(option, val)
)
def _ensure_tested_string(self, option, tester, what, error_fmt, default=None):
raise TypeError("'infiles' must be a string, or a list or tuple of strings")
if exec_msg is None:
- exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
+ exec_msg = "generating {} from {}".format(outfile, ', '.join(infiles))
# If 'outfile' must be regenerated (either because it doesn't
# exist, is out-of-date, or the 'force' flag is true) then
pretty_printer.print_help("List of available distribution formats:")
-class ListCompat(dict):
- # adapter to allow for Setuptools compatibility in format_commands
- def append(self, item):
- return
-
-
class bdist(Command):
description = "create a built (binary) distribution"
default_format = {'posix': 'gztar', 'nt': 'zip'}
# Define commands in preferred order for the --help-formats option
- format_commands = ListCompat(
- {
- 'rpm': ('bdist_rpm', "RPM distribution"),
- 'gztar': ('bdist_dumb', "gzip'ed tar file"),
- 'bztar': ('bdist_dumb', "bzip2'ed tar file"),
- 'xztar': ('bdist_dumb', "xz'ed tar file"),
- 'ztar': ('bdist_dumb', "compressed tar file"),
- 'tar': ('bdist_dumb', "tar file"),
- 'wininst': ('bdist_wininst', "Windows executable installer"),
- 'zip': ('bdist_dumb', "ZIP file"),
- 'msi': ('bdist_msi', "Microsoft Installer"),
- }
+ format_commands = dict(
+ rpm=('bdist_rpm', "RPM distribution"),
+ gztar=('bdist_dumb', "gzip'ed tar file"),
+ bztar=('bdist_dumb', "bzip2'ed tar file"),
+ xztar=('bdist_dumb', "xz'ed tar file"),
+ ztar=('bdist_dumb', "compressed tar file"),
+ tar=('bdist_dumb', "tar file"),
+ wininst=('bdist_wininst', "Windows executable installer"),
+ zip=('bdist_dumb', "ZIP file"),
+ msi=('bdist_msi', "Microsoft Installer"),
)
- # for compatibility until Setuptools references only format_commands
- format_command = format_commands
-
def initialize_options(self):
self.bdist_base = None
self.plat_name = None
# And make an archive relative to the root of the
# pseudo-installation tree.
- archive_basename = "%s.%s" % (self.distribution.get_fullname(), self.plat_name)
+ archive_basename = "{}.{}".format(
+ self.distribution.get_fullname(), self.plat_name
+ )
pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
if not self.relative:
if not target_version:
assert self.skip_build, "Should have already checked this"
target_version = '%d.%d' % sys.version_info[:2]
- plat_specifier = ".%s-%s" % (self.plat_name, target_version)
+ plat_specifier = ".{}-{}".format(self.plat_name, target_version)
build = self.get_finalized_command('build')
build.build_lib = os.path.join(build.build_base, 'lib' + plat_specifier)
# in Add-Remove-Programs (APR)
fullname = self.distribution.get_fullname()
if self.target_version:
- product_name = "Python %s %s" % (self.target_version, fullname)
+ product_name = "Python {} {}".format(self.target_version, fullname)
else:
product_name = "Python %s" % (fullname)
self.db = msilib.init_database(
for file in os.listdir(dir.absolute):
afile = os.path.join(dir.absolute, file)
if os.path.isdir(afile):
- short = "%s|%s" % (dir.make_short(file), file)
+ short = "{}|{}".format(dir.make_short(file), file)
default = file + version
newdir = Directory(db, cab, dir, file, default, short)
todo.append(newdir)
def get_installer_filename(self, fullname):
# Factored out to allow overriding in subclasses
if self.target_version:
- base_name = "%s.%s-py%s.msi" % (
+ base_name = "{}.{}-py{}.msi".format(
fullname,
self.plat_name,
self.target_version,
)
else:
- base_name = "%s.%s.msi" % (fullname, self.plat_name)
+ base_name = "{}.{}.msi".format(fullname, self.plat_name)
installer_name = os.path.join(self.dist_dir, base_name)
return installer_name
nvr_string = "%{name}-%{version}-%{release}"
src_rpm = nvr_string + ".src.rpm"
non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
- q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
+ q_cmd = r"rpm -q --qf '{} {}\n' --specfile '{}'".format(
src_rpm,
non_src_rpm,
spec_path,
):
val = getattr(self, field.lower())
if isinstance(val, list):
- spec_file.append('%s: %s' % (field, ' '.join(val)))
+ spec_file.append('{}: {}'.format(field, ' '.join(val)))
elif val is not None:
- spec_file.append('%s: %s' % (field, val))
+ spec_file.append('{}: {}'.format(field, val))
if self.distribution.get_url():
spec_file.append('Url: ' + self.distribution.get_url())
# rpm scripts
# figure out default build script
- def_setup_call = "%s %s" % (self.python, os.path.basename(sys.argv[0]))
+ def_setup_call = "{} {}".format(self.python, os.path.basename(sys.argv[0]))
def_build = "%s build" % def_setup_call
if self.use_rpm_opt_flags:
def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
if not target_version:
assert self.skip_build, "Should have already checked this"
target_version = '%d.%d' % sys.version_info[:2]
- plat_specifier = ".%s-%s" % (self.plat_name, target_version)
+ plat_specifier = ".{}-{}".format(self.plat_name, target_version)
build = self.get_finalized_command('build')
build.build_lib = os.path.join(build.build_base, 'lib' + plat_specifier)
]:
data = getattr(metadata, name, "")
if data:
- info = info + ("\n %s: %s" % (name.capitalize(), escape(data)))
- lines.append("%s=%s" % (name, escape(data)))
+ info = info + ("\n {}: {}".format(name.capitalize(), escape(data)))
+ lines.append("{}={}".format(name, escape(data)))
# The [setup] section contains entries controlling
# the installer runtime.
import time
import distutils
- build_info = "Built %s with distutils-%s" % (
+ build_info = "Built {} with distutils-{}".format(
time.ctime(time.time()),
distutils.__version__,
)
# We need to normalize newlines, so we open in text mode and
# convert back to bytes. "latin-1" simply avoids any possible
# failures.
- with open(self.pre_install_script, "r", encoding="latin-1") as script:
+ with open(self.pre_install_script, encoding="latin-1") as script:
script_data = script.read().encode("latin-1")
cfgdata = cfgdata + script_data + b"\n\0"
else:
# it's better to include this in the name
installer_name = os.path.join(
self.dist_dir,
- "%s.%s-py%s.exe" % (fullname, self.plat_name, self.target_version),
+ "{}.{}-py{}.exe".format(fullname, self.plat_name, self.target_version),
)
else:
installer_name = os.path.join(
- self.dist_dir, "%s.%s.exe" % (fullname, self.plat_name)
+ self.dist_dir, "{}.{}.exe".format(fullname, self.plat_name)
)
return installer_name
else:
sfix = ''
- filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
+ filename = os.path.join(directory, "wininst-{}{}.exe".format(bv, sfix))
f = open(filename, "rb")
try:
return f.read()
"using './configure --help' on your platform)"
)
- plat_specifier = ".%s-%s" % (self.plat_name, sys.implementation.cache_tag)
+ plat_specifier = ".{}-{}".format(self.plat_name, sys.implementation.cache_tag)
# Make it so Python 2.x and Python 2.x with --with-pydebug don't
# share the same build directories. Doing so confuses the build
except (CCompilerError, DistutilsError, CompileError) as e:
if not ext.optional:
raise
- self.warn('building extension "%s" failed: %s' % (ext.name, e))
+ self.warn('building extension "{}" failed: {}'.format(ext.name, e))
def build_extension(self, ext):
sources = ext.sources
if line is None:
warning = warning[1]
else:
- warning = '%s (line %s)' % (warning[1], line)
+ warning = '{} (line {})'.format(warning[1], line)
self.warn(warning)
def _check_rst_data(self, data):
auth.add_password(self.realm, host, username, password)
# send the info to the server and report the result
code, result = self.post_to_server(self.build_post_data('submit'), auth)
- self.announce('Server response (%s): %s' % (code, result), log.INFO)
+ self.announce('Server response ({}): {}'.format(code, result), log.INFO)
# possibly save the login
if code == 200:
log.info('Server response (%s): %s', code, result)
else:
log.info('You will receive an email shortly.')
- log.info(('Follow the instructions in it to ' 'complete registration.'))
+ log.info('Follow the instructions in it to ' 'complete registration.')
elif choice == '3':
data = {':action': 'password_reset'}
data['email'] = ''
'''Post a query to the server, and return a string response.'''
if 'name' in data:
self.announce(
- 'Registering %s to %s' % (data['name'], self.repository), log.INFO
+ 'Registering {} to {}'.format(data['name'], self.repository), log.INFO
)
# Build up the MIME payload for the urllib2 POST data
boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
seps = '/'
vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr', '_darcs']
- vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
+ vcs_ptrn = r'(^|{})({})({}).*'.format(seps, '|'.join(vcs_dirs), seps)
self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)
def write_manifest(self):
body.write(end_boundary)
body = body.getvalue()
- msg = "Submitting %s to %s" % (filename, self.repository)
+ msg = "Submitting {} to {}".format(filename, self.repository)
self.announce(msg, log.INFO)
# build the Request
raise
if status == 200:
- self.announce('Server response (%s): %s' % (status, reason), log.INFO)
+ self.announce('Server response ({}): {}'.format(status, reason), log.INFO)
if self.show_response:
text = self._read_pypi_response(result)
msg = '\n'.join(('-' * 75, text, '-' * 75))
self.announce(msg, log.INFO)
else:
- msg = 'Upload failed (%s): %s' % (status, reason)
+ msg = 'Upload failed ({}): {}'.format(status, reason)
self.announce(msg, log.ERROR)
raise DistutilsError(msg)
if 'name' not in attrs:
raise SystemExit("error in setup command: %s" % msg)
else:
- raise SystemExit("error in %s setup command: %s" % (attrs['name'], msg))
+ raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg))
if _setup_stop_after == "init":
return dist
raise SystemExit("interrupted")
except OSError as exc:
if DEBUG:
- sys.stderr.write("error: %s\n" % (exc,))
+ sys.stderr.write("error: {}\n".format(exc))
raise
else:
- raise SystemExit("error: %s" % (exc,))
+ raise SystemExit("error: {}".format(exc))
except (DistutilsError, CCompilerError) as msg:
if DEBUG:
used to drive the Distutils.
"""
if stop_after not in ('init', 'config', 'commandline', 'run'):
- raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))
+ raise ValueError("invalid value for 'stop_after': {!r}".format(stop_after))
global _setup_stop_after, _setup_distribution
_setup_stop_after = stop_after
super().__init__(verbose, dry_run, force)
status, details = check_config_h()
- self.debug_print("Python's GCC status: %s (details: %s)" % (status, details))
+ self.debug_print(
+ "Python's GCC status: {} (details: {})".format(status, details)
+ )
if status is not CONFIG_H_OK:
self.warn(
"Python's pyconfig.h doesn't seem to support your compiler. "
compiler_so='%s -mcygwin -mdll -O -Wall' % self.cc,
compiler_cxx='%s -mcygwin -O -Wall' % self.cxx,
linker_exe='%s -mcygwin' % self.cc,
- linker_so=('%s -mcygwin %s' % (self.linker_dll, shared_option)),
+ linker_so=('{} -mcygwin {}'.format(self.linker_dll, shared_option)),
)
# Include the appropriate MSVC runtime library if Python was built
base, ext = os.path.splitext(os.path.normcase(src_name))
if ext not in (self.src_extensions + ['.rc', '.res']):
raise UnknownFileError(
- "unknown file type '%s' (from '%s')" % (ext, src_name)
+ "unknown file type '{}' (from '{}')".format(ext, src_name)
)
if strip_dir:
base = os.path.basename(base)
compiler_so='%s -mdll -O -Wall' % self.cc,
compiler_cxx='%s -O -Wall' % self.cxx,
linker_exe='%s' % self.cc,
- linker_so='%s %s' % (self.linker_dll, shared_option),
+ linker_so='{} {}'.format(self.linker_dll, shared_option),
)
# Maybe we should also append -mthreads, but then the finished
finally:
config_h.close()
except OSError as exc:
- return (CONFIG_H_UNCERTAIN, "couldn't read '%s': %s" % (fn, exc.strerror))
+ return (CONFIG_H_UNCERTAIN, "couldn't read '{}': {}".format(fn, exc.strerror))
def is_cygwincc(cc):
# Detect a common bug -- name is None
if not isinstance(name, str):
raise DistutilsInternalError(
- "mkpath: 'name' must be a string (got %r)" % (name,)
+ "mkpath: 'name' must be a string (got {!r})".format(name)
)
# XXX what's the better way to handle verbosity? print as we create
except OSError as exc:
if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
raise DistutilsFileError(
- "could not create '%s': %s" % (head, exc.args[-1])
+ "could not create '{}': {}".format(head, exc.args[-1])
)
created_dirs.append(head)
names = []
else:
raise DistutilsFileError(
- "error listing files in '%s': %s" % (src, e.strerror)
+ "error listing files in '{}': {}".format(src, e.strerror)
)
if not dry_run:
return klass
for pkgname in self.get_command_packages():
- module_name = "%s.%s" % (pkgname, command)
+ module_name = "{}.{}".format(pkgname, command)
klass_name = command
try:
self.announce(" setting options for '%s' command:" % command_name)
for (option, (source, value)) in option_dict.items():
if DEBUG:
- self.announce(" %s = %s (from %s)" % (option, value, source))
+ self.announce(" {} = {} (from {})".format(option, value, source))
try:
bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
except AttributeError:
def maybe_write(header, val):
if val:
- file.write("{}: {}\n".format(header, val))
+ file.write(f"{header}: {val}\n")
# optional fields
maybe_write("Summary", self.get_description())
def _write_list(self, file, name, values):
values = values or []
for value in values:
- file.write('%s: %s\n' % (name, value))
+ file.write('{}: {}\n'.format(name, value))
# -- Metadata query methods ----------------------------------------
return self.version or "0.0.0"
def get_fullname(self):
- return "%s-%s" % (self.get_name(), self.get_version())
+ return "{}-{}".format(self.get_name(), self.get_version())
def get_author(self):
return self.author
warnings.warn(msg)
def __repr__(self):
- return '<%s.%s(%r) at %#x>' % (
+ return '<{}.{}({!r}) at {:#x}>'.format(
self.__class__.__module__,
self.__class__.__qualname__,
self.name,
longopt_re = re.compile(r'^%s$' % longopt_pat)
# For recognizing "negative alias" options, eg. "quiet=!verbose"
-neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))
+neg_alias_re = re.compile("^({})=!({})$".format(longopt_pat, longopt_pat))
# This is used to translate long options to legitimate Python identifiers
# (for use as attributes of some object).
else:
# the option table is part of the code, so simply
# assert that it is correct
- raise ValueError("invalid option tuple: %r" % (option,))
+ raise ValueError("invalid option tuple: {!r}".format(option))
# Type- and value-check the option names
if not isinstance(long, str) or len(long) < 2:
# Case 2: we have a short option, so we have to include it
# just after the long option
else:
- opt_names = "%s (-%s)" % (long, short)
+ opt_names = "{} (-{})".format(long, short)
if text:
lines.append(" --%-*s %s" % (max_opt, opt_names, text[0]))
else:
try:
fsrc = open(src, 'rb')
except OSError as e:
- raise DistutilsFileError("could not open '%s': %s" % (src, e.strerror))
+ raise DistutilsFileError("could not open '{}': {}".format(src, e.strerror))
if os.path.exists(dst):
try:
os.unlink(dst)
except OSError as e:
raise DistutilsFileError(
- "could not delete '%s': %s" % (dst, e.strerror)
+ "could not delete '{}': {}".format(dst, e.strerror)
)
try:
fdst = open(dst, 'wb')
except OSError as e:
- raise DistutilsFileError("could not create '%s': %s" % (dst, e.strerror))
+ raise DistutilsFileError(
+ "could not create '{}': {}".format(dst, e.strerror)
+ )
while True:
try:
buf = fsrc.read(buffer_size)
except OSError as e:
raise DistutilsFileError(
- "could not read from '%s': %s" % (src, e.strerror)
+ "could not read from '{}': {}".format(src, e.strerror)
)
if not buf:
fdst.write(buf)
except OSError as e:
raise DistutilsFileError(
- "could not write to '%s': %s" % (dst, e.strerror)
+ "could not write to '{}': {}".format(dst, e.strerror)
)
finally:
if fdst:
dst = os.path.join(dst, basename(src))
elif exists(dst):
raise DistutilsFileError(
- "can't move '%s': destination '%s' already exists" % (src, dst)
+ "can't move '{}': destination '{}' already exists".format(src, dst)
)
if not isdir(dirname(dst)):
raise DistutilsFileError(
- "can't move '%s': destination '%s' not a valid path" % (src, dst)
+ "can't move '{}': destination '{}' not a valid path".format(src, dst)
)
copy_it = False
if num == errno.EXDEV:
copy_it = True
else:
- raise DistutilsFileError("couldn't move '%s' to '%s': %s" % (src, dst, msg))
+ raise DistutilsFileError(
+ "couldn't move '{}' to '{}': {}".format(src, dst, msg)
+ )
if copy_it:
copy_file(src, dst, verbose=verbose)
)
elif action == 'recursive-include':
- self.debug_print("recursive-include %s %s" % (dir, ' '.join(patterns)))
+ self.debug_print("recursive-include {} {}".format(dir, ' '.join(patterns)))
for pattern in patterns:
if not self.include_pattern(pattern, prefix=dir):
msg = (
log.warn(msg, pattern, dir)
elif action == 'recursive-exclude':
- self.debug_print("recursive-exclude %s %s" % (dir, ' '.join(patterns)))
+ self.debug_print("recursive-exclude {} {}".format(dir, ' '.join(patterns)))
for pattern in patterns:
if not self.exclude_pattern(pattern, prefix=dir):
log.warn(
if os.sep == '\\':
sep = r'\\'
pattern_re = pattern_re[len(start) : len(pattern_re) - len(end)]
- pattern_re = r'%s\A%s%s.*%s%s' % (start, prefix_re, sep, pattern_re, end)
+ pattern_re = r'{}\A{}{}.*{}{}'.format(start, prefix_re, sep, pattern_re, end)
else: # no prefix -- respect anchor flag
if anchor:
- pattern_re = r'%s\A%s' % (start, pattern_re[len(start) :])
+ pattern_re = r'{}\A{}'.format(start, pattern_re[len(start) :])
return re.compile(pattern_re)
except RegError:
continue
key = RegEnumKey(h, 0)
- d = Reg.get_value(base, r"%s\%s" % (p, key))
+ d = Reg.get_value(base, r"{}\{}".format(p, key))
self.macros["$(FrameworkVersion)"] = d["version"]
def sub(self, s):
raise DistutilsPlatformError("Unable to find vcvarsall.bat")
log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
popen = subprocess.Popen(
- '"%s" %s & set' % (vcvarsall, arch),
+ '"{}" {} & set'.format(vcvarsall, arch),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
# sanity check for platforms to prevent obscure errors later.
ok_plats = 'win32', 'win-amd64'
if plat_name not in ok_plats:
- raise DistutilsPlatformError("--plat-name must be one of %s" % (ok_plats,))
+ raise DistutilsPlatformError(
+ "--plat-name must be one of {}".format(ok_plats)
+ )
if (
"DISTUTILS_USE_SDK" in os.environ
continue
else:
# how to handle this file?
- raise CompileError("Don't know how to compile %s to %s" % (src, obj))
+ raise CompileError(
+ "Don't know how to compile {} to {}".format(src, obj)
+ )
output_opt = "/Fo" + obj
try:
mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
if mfinfo is not None:
mffilename, mfid = mfinfo
- out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
+ out_arg = '-outputresource:{};{}'.format(output_filename, mfid)
try:
self.spawn(['mt.exe', '-nologo', '-manifest', mffilename, out_arg])
except DistutilsExecError as msg:
except RegError:
continue
key = RegEnumKey(h, 0)
- d = read_values(base, r"%s\%s" % (p, key))
+ d = read_values(base, r"{}\{}".format(p, key))
self.macros["$(FrameworkVersion)"] = d["version"]
def sub(self, s):
continue
else:
# how to handle this file?
- raise CompileError("Don't know how to compile %s to %s" % (src, obj))
+ raise CompileError(
+ "Don't know how to compile {} to {}".format(src, obj)
+ )
output_opt = "/Fo" + obj
try:
path = path + " dirs"
if self.__version >= 7:
- key = r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories" % (
+ key = r"{}\{:0.1f}\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories".format(
self.__root,
self.__version,
)
return _aix_support.aix_platform()
except ImportError:
pass
- return "%s-%s.%s" % (osname, version, release)
+ return "{}-{}.{}".format(osname, version, release)
except OSError as exc:
if not DEBUG:
cmd = cmd[0]
- raise DistutilsExecError("command %r failed: %s" % (cmd, exc.args[-1])) from exc
+ raise DistutilsExecError(
+ "command {!r} failed: {}".format(cmd, exc.args[-1])
+ ) from exc
if exitcode:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError(
- "command %r failed with exit code %s" % (cmd, exitcode)
+ "command {!r} failed with exit code {}".format(cmd, exitcode)
)
import tempfile
import unittest
import sysconfig
+import itertools
-from . import py38compat as os_helper
+import pytest
-from distutils import log
from distutils.log import DEBUG, INFO, WARN, ERROR, FATAL
from distutils.core import Distribution
-class LoggingSilencer(object):
- def setUp(self):
- super().setUp()
- self.threshold = log.set_threshold(log.FATAL)
- # catching warnings
- # when log will be replaced by logging
- # we won't need such monkey-patch anymore
- self._old_log = log.Log._log
- log.Log._log = self._log
- self.logs = []
-
- def tearDown(self):
- log.set_threshold(self.threshold)
- log.Log._log = self._old_log
- super().tearDown()
-
+@pytest.mark.usefixtures('distutils_logging_silencer')
+class LoggingSilencer:
def _log(self, level, msg, args):
if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
raise ValueError('%s wrong log level' % str(level))
self.logs = []
-class TempdirManager(object):
+@pytest.mark.usefixtures('distutils_managed_tempdir')
+class TempdirManager:
"""Mix-in class that handles temporary directories for test cases.
This is intended to be used with unittest.TestCase.
"""
- def setUp(self):
- super().setUp()
- self.old_cwd = os.getcwd()
- self.tempdirs = []
-
- def tearDown(self):
- # Restore working dir, for Solaris and derivatives, where rmdir()
- # on the current directory fails.
- os.chdir(self.old_cwd)
- super().tearDown()
- while self.tempdirs:
- tmpdir = self.tempdirs.pop()
- os_helper.rmtree(tmpdir)
-
def mkdtemp(self):
"""Create a temporary directory that will be cleaned up.
"""Class to store options for retrieval via set_undefined_options()."""
def __init__(self, **kwargs):
- for kw, val in kwargs.items():
- setattr(self, kw, val)
+ vars(self).update(kwargs)
def ensure_finalized(self):
pass
else:
name, equals, value = runshared.partition('=')
cmd.library_dirs = [d for d in value.split(os.pathsep) if d]
+
+
+def combine_markers(cls):
+ """
+ pytest will honor markers as found on the class, but when
+ markers are on multiple subclasses, only one appears. Use
+ this decorator to combine those markers.
+ """
+ cls.pytestmark = [
+ mark
+ for base in itertools.chain([cls], cls.__bases__)
+ for mark in getattr(base, 'pytestmark', [])
+ ]
+ return cls
-# -*- coding: utf-8 -*-
"""Tests for distutils.archive_util."""
import unittest
import os
return True
-class ArchiveUtilTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+class ArchiveUtilTestCase(support.TempdirManager, support.LoggingSilencer):
@pytest.mark.usefixtures('needs_zlib')
def test_make_tarball(self, name='archive'):
# creating something to tar
# check if the compressed tarball was created
tarball = base_name + suffix
- self.assertTrue(os.path.exists(tarball))
- self.assertEqual(self._tarinfo(tarball), self._created_files)
+ assert os.path.exists(tarball)
+ assert self._tarinfo(tarball) == self._created_files
def _tarinfo(self, path):
tar = tarfile.open(path)
# check if the compressed tarball was created
tarball = base_name + '.tar.gz'
- self.assertTrue(os.path.exists(tarball))
+ assert os.path.exists(tarball)
# now create another tarball using `tar`
tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
finally:
os.chdir(old_dir)
- self.assertTrue(os.path.exists(tarball2))
+ assert os.path.exists(tarball2)
# let's compare both tarballs
- self.assertEqual(self._tarinfo(tarball), self._created_files)
- self.assertEqual(self._tarinfo(tarball2), self._created_files)
+ assert self._tarinfo(tarball) == self._created_files
+ assert self._tarinfo(tarball2) == self._created_files
# trying an uncompressed one
base_name = os.path.join(tmpdir2, 'archive')
finally:
os.chdir(old_dir)
tarball = base_name + '.tar'
- self.assertTrue(os.path.exists(tarball))
+ assert os.path.exists(tarball)
# now for a dry_run
base_name = os.path.join(tmpdir2, 'archive')
finally:
os.chdir(old_dir)
tarball = base_name + '.tar'
- self.assertTrue(os.path.exists(tarball))
+ assert os.path.exists(tarball)
@unittest.skipUnless(
find_executable('compress'), 'The compress program is required'
finally:
os.chdir(old_dir)
tarball = base_name + '.tar.Z'
- self.assertTrue(os.path.exists(tarball))
- self.assertEqual(len(w.warnings), 1)
+ assert os.path.exists(tarball)
+ assert len(w.warnings) == 1
# same test with dry_run
os.remove(tarball)
make_tarball(base_name, 'dist', compress='compress', dry_run=True)
finally:
os.chdir(old_dir)
- self.assertFalse(os.path.exists(tarball))
- self.assertEqual(len(w.warnings), 1)
+ assert not os.path.exists(tarball)
+ assert len(w.warnings) == 1
@pytest.mark.usefixtures('needs_zlib')
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
# check if the compressed tarball was created
tarball = base_name + '.zip'
- self.assertTrue(os.path.exists(tarball))
+ assert os.path.exists(tarball)
with zipfile.ZipFile(tarball) as zf:
- self.assertEqual(sorted(zf.namelist()), self._zip_created_files)
+ assert sorted(zf.namelist()) == self._zip_created_files
@unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run')
def test_make_zipfile_no_zlib(self):
make_zipfile(base_name, 'dist')
tarball = base_name + '.zip'
- self.assertEqual(
- called, [((tarball, "w"), {'compression': zipfile.ZIP_STORED})]
- )
- self.assertTrue(os.path.exists(tarball))
+ assert called == [((tarball, "w"), {'compression': zipfile.ZIP_STORED})]
+ assert os.path.exists(tarball)
with zipfile.ZipFile(tarball) as zf:
- self.assertEqual(sorted(zf.namelist()), self._zip_created_files)
+ assert sorted(zf.namelist()) == self._zip_created_files
def test_check_archive_formats(self):
- self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']), 'xxx')
- self.assertIsNone(
+ assert check_archive_formats(['gztar', 'xxx', 'zip']) == 'xxx'
+ assert (
check_archive_formats(['gztar', 'bztar', 'xztar', 'ztar', 'tar', 'zip'])
+ is None
)
def test_make_archive(self):
tmpdir = self.mkdtemp()
base_name = os.path.join(tmpdir, 'archive')
- self.assertRaises(ValueError, make_archive, base_name, 'xxx')
+ with pytest.raises(ValueError):
+ make_archive(base_name, 'xxx')
def test_make_archive_cwd(self):
current_dir = os.getcwd()
make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
except Exception:
pass
- self.assertEqual(os.getcwd(), current_dir)
+ assert os.getcwd() == current_dir
finally:
del ARCHIVE_FORMATS['xxx']
base_dir = self._create_files()
base_name = os.path.join(self.mkdtemp(), 'archive')
res = make_archive(base_name, 'tar', base_dir, 'dist')
- self.assertTrue(os.path.exists(res))
- self.assertEqual(os.path.basename(res), 'archive.tar')
- self.assertEqual(self._tarinfo(res), self._created_files)
+ assert os.path.exists(res)
+ assert os.path.basename(res) == 'archive.tar'
+ assert self._tarinfo(res) == self._created_files
@pytest.mark.usefixtures('needs_zlib')
def test_make_archive_gztar(self):
base_dir = self._create_files()
base_name = os.path.join(self.mkdtemp(), 'archive')
res = make_archive(base_name, 'gztar', base_dir, 'dist')
- self.assertTrue(os.path.exists(res))
- self.assertEqual(os.path.basename(res), 'archive.tar.gz')
- self.assertEqual(self._tarinfo(res), self._created_files)
+ assert os.path.exists(res)
+ assert os.path.basename(res) == 'archive.tar.gz'
+ assert self._tarinfo(res) == self._created_files
@unittest.skipUnless(bz2, 'Need bz2 support to run')
def test_make_archive_bztar(self):
base_dir = self._create_files()
base_name = os.path.join(self.mkdtemp(), 'archive')
res = make_archive(base_name, 'bztar', base_dir, 'dist')
- self.assertTrue(os.path.exists(res))
- self.assertEqual(os.path.basename(res), 'archive.tar.bz2')
- self.assertEqual(self._tarinfo(res), self._created_files)
+ assert os.path.exists(res)
+ assert os.path.basename(res) == 'archive.tar.bz2'
+ assert self._tarinfo(res) == self._created_files
@unittest.skipUnless(lzma, 'Need xz support to run')
def test_make_archive_xztar(self):
base_dir = self._create_files()
base_name = os.path.join(self.mkdtemp(), 'archive')
res = make_archive(base_name, 'xztar', base_dir, 'dist')
- self.assertTrue(os.path.exists(res))
- self.assertEqual(os.path.basename(res), 'archive.tar.xz')
- self.assertEqual(self._tarinfo(res), self._created_files)
+ assert os.path.exists(res)
+ assert os.path.basename(res) == 'archive.tar.xz'
+ assert self._tarinfo(res) == self._created_files
def test_make_archive_owner_group(self):
# testing make_archive with owner and group, with various combinations
res = make_archive(
base_name, 'zip', root_dir, base_dir, owner=owner, group=group
)
- self.assertTrue(os.path.exists(res))
+ assert os.path.exists(res)
res = make_archive(base_name, 'zip', root_dir, base_dir)
- self.assertTrue(os.path.exists(res))
+ assert os.path.exists(res)
res = make_archive(
base_name, 'tar', root_dir, base_dir, owner=owner, group=group
)
- self.assertTrue(os.path.exists(res))
+ assert os.path.exists(res)
res = make_archive(
base_name, 'tar', root_dir, base_dir, owner='kjhkjhkjg', group='oihohoh'
)
- self.assertTrue(os.path.exists(res))
+ assert os.path.exists(res)
@pytest.mark.usefixtures('needs_zlib')
@require_unix_id
os.chdir(old_dir)
# check if the compressed tarball was created
- self.assertTrue(os.path.exists(archive_name))
+ assert os.path.exists(archive_name)
# now checks the rights
archive = tarfile.open(archive_name)
try:
for member in archive.getmembers():
- self.assertEqual(member.uid, 0)
- self.assertEqual(member.gid, 0)
+ assert member.uid == 0
+ assert member.gid == 0
finally:
archive.close()
"""Tests for distutils.command.bdist."""
import os
-import unittest
import warnings
from distutils.command.bdist import bdist
from distutils.tests import support
-class BuildTestCase(support.TempdirManager, unittest.TestCase):
+class TestBuild(support.TempdirManager):
def test_formats(self):
# let's create a command and make sure
# we can set the format
cmd = bdist(dist)
cmd.formats = ['msi']
cmd.ensure_finalized()
- self.assertEqual(cmd.formats, ['msi'])
+ assert cmd.formats == ['msi']
# what formats does bdist offer?
formats = [
'ztar',
]
found = sorted(cmd.format_commands)
- self.assertEqual(found, formats)
+ assert found == formats
def test_skip_build(self):
# bug #10946: bdist --skip-build should trickle down to subcommands
if getattr(subcmd, '_unsupported', False):
# command is not supported on this build
continue
- self.assertTrue(
- subcmd.skip_build, '%s should take --skip-build from bdist' % name
- )
+ assert subcmd.skip_build, '%s should take --skip-build from bdist' % name
import os
import sys
import zipfile
-import unittest
import pytest
"""
+@support.combine_markers
@pytest.mark.usefixtures('save_env')
-class BuildDumbTestCase(
+@pytest.mark.usefixtures('save_argv')
+@pytest.mark.usefixtures('save_cwd')
+class TestBuildDumb(
support.TempdirManager,
support.LoggingSilencer,
- unittest.TestCase,
):
- def setUp(self):
- super(BuildDumbTestCase, self).setUp()
- self.old_location = os.getcwd()
- self.old_sys_argv = sys.argv, sys.argv[:]
-
- def tearDown(self):
- os.chdir(self.old_location)
- sys.argv = self.old_sys_argv[0]
- sys.argv[:] = self.old_sys_argv[1]
- super(BuildDumbTestCase, self).tearDown()
-
@pytest.mark.usefixtures('needs_zlib')
def test_simple_built(self):
# see what we have
dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
- base = "%s.%s.zip" % (dist.get_fullname(), cmd.plat_name)
+ base = "{}.{}.zip".format(dist.get_fullname(), cmd.plat_name)
- self.assertEqual(dist_created, [base])
+ assert dist_created == [base]
# now let's check what we have in the zip file
fp = zipfile.ZipFile(os.path.join('dist', base))
wanted = ['foo-0.1-py%s.%s.egg-info' % sys.version_info[:2], 'foo.py']
if not sys.dont_write_bytecode:
wanted.append('foo.%s.pyc' % sys.implementation.cache_tag)
- self.assertEqual(contents, sorted(wanted))
+ assert contents == sorted(wanted)
"""Tests for distutils.command.bdist_msi."""
-import sys
-import unittest
+import pytest
+
from distutils.tests import support
from .py38compat import check_warnings
-@unittest.skipUnless(sys.platform == 'win32', 'these tests require Windows')
-class BDistMSITestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+pytest.importorskip('msilib')
+
+
+class TestBDistMSI(support.TempdirManager, support.LoggingSilencer):
def test_minimal(self):
# minimal test XXX need more tests
from distutils.command.bdist_msi import bdist_msi
"""
+@pytest.fixture(autouse=True)
+def sys_executable_encodable():
+ try:
+ sys.executable.encode('UTF-8')
+ except UnicodeEncodeError:
+ pytest.skip("sys.executable is not encodable to UTF-8")
+
+
@pytest.mark.usefixtures('save_env')
-class BuildRpmTestCase(
+@pytest.mark.usefixtures('save_argv')
+@pytest.mark.usefixtures('save_cwd')
+class TestBuildRpm(
support.TempdirManager,
support.LoggingSilencer,
- unittest.TestCase,
):
- def setUp(self):
- try:
- sys.executable.encode("UTF-8")
- except UnicodeEncodeError:
- raise unittest.SkipTest("sys.executable is not encodable to UTF-8")
-
- super(BuildRpmTestCase, self).setUp()
- self.old_location = os.getcwd()
- self.old_sys_argv = sys.argv, sys.argv[:]
-
- def tearDown(self):
- os.chdir(self.old_location)
- sys.argv = self.old_sys_argv[0]
- sys.argv[:] = self.old_sys_argv[1]
- super(BuildRpmTestCase, self).tearDown()
# XXX I am unable yet to make this test work without
# spurious sdtout/stderr output under Mac OS X
cmd.run()
dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
- self.assertIn('foo-0.1-1.noarch.rpm', dist_created)
+ assert 'foo-0.1-1.noarch.rpm' in dist_created
# bug #2945: upload ignores bdist_rpm files
- self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files)
- self.assertIn(
- ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm'), dist.dist_files
- )
+ assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+ assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
# XXX I am unable yet to make this test work without
# spurious sdtout/stderr output under Mac OS X
cmd.run()
dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
- self.assertIn('foo-0.1-1.noarch.rpm', dist_created)
+ assert 'foo-0.1-1.noarch.rpm' in dist_created
# bug #2945: upload ignores bdist_rpm files
- self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files)
- self.assertIn(
- ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm'), dist.dist_files
- )
+ assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+ assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))
getattr(bdist_wininst, '_unsupported', False),
'bdist_wininst is not supported in this install',
)
-class BuildWinInstTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+class TestBuildWinInst(support.TempdirManager, support.LoggingSilencer):
def test_get_exe_bytes(self):
# issue5731: command was broken on non-windows platforms
# and make sure it finds it and returns its content
# no matter what platform we have
exe_file = cmd.get_exe_bytes()
- self.assertGreater(len(exe_file), 10)
+ assert len(exe_file) > 10
cmd.finalize_options()
# if not specified, plat_name gets the current platform
- self.assertEqual(cmd.plat_name, get_platform())
+ assert cmd.plat_name == get_platform()
# build_purelib is build + lib
wanted = os.path.join(cmd.build_base, 'lib')
- self.assertEqual(cmd.build_purelib, wanted)
+ assert cmd.build_purelib == wanted
# build_platlib is 'build/lib.platform-cache_tag[-pydebug]'
# examples:
# build/lib.macosx-10.3-i386-cpython39
- plat_spec = '.%s-%s' % (cmd.plat_name, sys.implementation.cache_tag)
+ plat_spec = '.{}-{}'.format(cmd.plat_name, sys.implementation.cache_tag)
if hasattr(sys, 'gettotalrefcount'):
- self.assertTrue(cmd.build_platlib.endswith('-pydebug'))
+ assert cmd.build_platlib.endswith('-pydebug')
plat_spec += '-pydebug'
wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
- self.assertEqual(cmd.build_platlib, wanted)
+ assert cmd.build_platlib == wanted
# by default, build_lib = build_purelib
- self.assertEqual(cmd.build_lib, cmd.build_purelib)
+ assert cmd.build_lib == cmd.build_purelib
# build_temp is build/temp.<plat>
wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
- self.assertEqual(cmd.build_temp, wanted)
+ assert cmd.build_temp == wanted
# build_scripts is build/scripts-x.x
wanted = os.path.join(cmd.build_base, 'scripts-%d.%d' % sys.version_info[:2])
- self.assertEqual(cmd.build_scripts, wanted)
+ assert cmd.build_scripts == wanted
# executable is os.path.normpath(sys.executable)
- self.assertEqual(cmd.executable, os.path.normpath(sys.executable))
+ assert cmd.executable == os.path.normpath(sys.executable)
from distutils.command.build_clib import build_clib
from distutils.errors import DistutilsSetupError
from distutils.tests import support
+import pytest
-class BuildCLibTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+class TestBuildCLib(support.TempdirManager, support.LoggingSilencer):
def test_check_library_dist(self):
pkg_dir, dist = self.create_dist()
cmd = build_clib(dist)
# 'libraries' option must be a list
- self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_library_list('foo')
# each element of 'libraries' must a 2-tuple
- self.assertRaises(DistutilsSetupError, cmd.check_library_list, ['foo1', 'foo2'])
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_library_list(['foo1', 'foo2'])
# first element of each tuple in 'libraries'
# must be a string (the library name)
- self.assertRaises(
- DistutilsSetupError, cmd.check_library_list, [(1, 'foo1'), ('name', 'foo2')]
- )
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_library_list([(1, 'foo1'), ('name', 'foo2')])
# library name may not contain directory separators
- self.assertRaises(
- DistutilsSetupError,
- cmd.check_library_list,
- [('name', 'foo1'), ('another/name', 'foo2')],
- )
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_library_list(
+ [('name', 'foo1'), ('another/name', 'foo2')],
+ )
# second element of each tuple must be a dictionary (build info)
- self.assertRaises(
- DistutilsSetupError,
- cmd.check_library_list,
- [('name', {}), ('another', 'foo2')],
- )
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_library_list(
+ [('name', {}), ('another', 'foo2')],
+ )
# those work
libs = [('name', {}), ('name', {'ok': 'good'})]
# "in 'libraries' option 'sources' must be present and must be
# a list of source filenames
cmd.libraries = [('name', {})]
- self.assertRaises(DistutilsSetupError, cmd.get_source_files)
+ with pytest.raises(DistutilsSetupError):
+ cmd.get_source_files()
cmd.libraries = [('name', {'sources': 1})]
- self.assertRaises(DistutilsSetupError, cmd.get_source_files)
+ with pytest.raises(DistutilsSetupError):
+ cmd.get_source_files()
cmd.libraries = [('name', {'sources': ['a', 'b']})]
- self.assertEqual(cmd.get_source_files(), ['a', 'b'])
+ assert cmd.get_source_files() == ['a', 'b']
cmd.libraries = [('name', {'sources': ('a', 'b')})]
- self.assertEqual(cmd.get_source_files(), ['a', 'b'])
+ assert cmd.get_source_files() == ['a', 'b']
cmd.libraries = [
('name', {'sources': ('a', 'b')}),
('name2', {'sources': ['c', 'd']}),
]
- self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
+ assert cmd.get_source_files() == ['a', 'b', 'c', 'd']
def test_build_libraries(self):
# build_libraries is also doing a bit of typo checking
lib = [('name', {'sources': 'notvalid'})]
- self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)
+ with pytest.raises(DistutilsSetupError):
+ cmd.build_libraries(lib)
lib = [('name', {'sources': list()})]
cmd.build_libraries(lib)
cmd.include_dirs = 'one-dir'
cmd.finalize_options()
- self.assertEqual(cmd.include_dirs, ['one-dir'])
+ assert cmd.include_dirs == ['one-dir']
cmd.include_dirs = None
cmd.finalize_options()
- self.assertEqual(cmd.include_dirs, [])
+ assert cmd.include_dirs == []
cmd.distribution.libraries = 'WONTWORK'
- self.assertRaises(DistutilsSetupError, cmd.finalize_options)
+ with pytest.raises(DistutilsSetupError):
+ cmd.finalize_options()
@unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
def test_run(self):
cmd.run()
# let's check the result
- self.assertIn('libfoo.a', os.listdir(build_temp))
+ assert 'libfoo.a' in os.listdir(build_temp)
import os
from io import StringIO
import textwrap
+import site
from distutils.core import Distribution
from distutils.command.build_ext import build_ext
LoggingSilencer,
copy_xxmodule_c,
fixup_build_ext,
+ combine_markers,
)
from distutils.extension import Extension
from distutils.errors import (
from test import support
from . import py38compat as os_helper
from test.support.script_helper import assert_python_ok
+import pytest
+import re
# http://bugs.python.org/issue4373
# Don't load the xx module more than once.
ALREADY_TESTED = False
-class BuildExtTestCase(TempdirManager, LoggingSilencer, unittest.TestCase):
- def setUp(self):
- # Create a simple test environment
- super(BuildExtTestCase, self).setUp()
- self.tmp_dir = self.mkdtemp()
- import site
-
- self.old_user_base = site.USER_BASE
- site.USER_BASE = self.mkdtemp()
- from distutils.command import build_ext
+@pytest.fixture()
+def user_site_dir(request):
+ self = request.instance
+ self.tmp_dir = self.mkdtemp()
+ from distutils.command import build_ext
- build_ext.USER_BASE = site.USER_BASE
+ orig_user_base = site.USER_BASE
- # bpo-30132: On Windows, a .pdb file may be created in the current
- # working directory. Create a temporary working directory to cleanup
- # everything at the end of the test.
- change_cwd = os_helper.change_cwd(self.tmp_dir)
- change_cwd.__enter__()
- self.addCleanup(change_cwd.__exit__, None, None, None)
+ site.USER_BASE = self.mkdtemp()
+ build_ext.USER_BASE = site.USER_BASE
- def tearDown(self):
- import site
+ # bpo-30132: On Windows, a .pdb file may be created in the current
+ # working directory. Create a temporary working directory to cleanup
+ # everything at the end of the test.
+ with os_helper.change_cwd(self.tmp_dir):
+ yield
- site.USER_BASE = self.old_user_base
- from distutils.command import build_ext
+ site.USER_BASE = orig_user_base
+ build_ext.USER_BASE = orig_user_base
- build_ext.USER_BASE = self.old_user_base
- super(BuildExtTestCase, self).tearDown()
+@pytest.mark.usefixtures('user_site_dir')
+class TestBuildExt(TempdirManager, LoggingSilencer):
def build_ext(self, *args, **kwargs):
return build_ext(*args, **kwargs)
ALREADY_TESTED = type(self).__name__
code = textwrap.dedent(
- """
+ f"""
tmp_dir = {self.tmp_dir!r}
import sys
unittest.main()
- """.format(
- **locals()
- )
+ """
)
assert_python_ok('-c', code)
_config_vars['Py_ENABLE_SHARED'] = old_var
# make sure we get some library dirs under solaris
- self.assertGreater(len(cmd.library_dirs), 0)
+ assert len(cmd.library_dirs) > 0
def test_user_site(self):
import site
# making sure the user option is there
options = [name for name, short, lable in cmd.user_options]
- self.assertIn('user', options)
+ assert 'user' in options
# setting a value
cmd.user = 1
# see if include_dirs and library_dirs
# were set
- self.assertIn(lib, cmd.library_dirs)
- self.assertIn(lib, cmd.rpath)
- self.assertIn(incl, cmd.include_dirs)
+ assert lib in cmd.library_dirs
+ assert lib in cmd.rpath
+ assert incl in cmd.include_dirs
def test_optional_extension(self):
dist = Distribution({'name': 'xx', 'ext_modules': modules})
cmd = self.build_ext(dist)
cmd.ensure_finalized()
- self.assertRaises(
- (UnknownFileError, CompileError), cmd.run
- ) # should raise an error
+ with pytest.raises((UnknownFileError, CompileError)):
+ cmd.run() # should raise an error
modules = [Extension('foo', ['xxx'], optional=True)]
dist = Distribution({'name': 'xx', 'ext_modules': modules})
py_include = sysconfig.get_python_inc()
for p in py_include.split(os.path.pathsep):
- self.assertIn(p, cmd.include_dirs)
+ assert p in cmd.include_dirs
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
for p in plat_py_include.split(os.path.pathsep):
- self.assertIn(p, cmd.include_dirs)
+ assert p in cmd.include_dirs
# make sure cmd.libraries is turned into a list
# if it's a string
cmd = self.build_ext(dist)
cmd.libraries = 'my_lib, other_lib lastlib'
cmd.finalize_options()
- self.assertEqual(cmd.libraries, ['my_lib', 'other_lib', 'lastlib'])
+ assert cmd.libraries == ['my_lib', 'other_lib', 'lastlib']
# make sure cmd.library_dirs is turned into a list
# if it's a string
cmd = self.build_ext(dist)
cmd.library_dirs = 'my_lib_dir%sother_lib_dir' % os.pathsep
cmd.finalize_options()
- self.assertIn('my_lib_dir', cmd.library_dirs)
- self.assertIn('other_lib_dir', cmd.library_dirs)
+ assert 'my_lib_dir' in cmd.library_dirs
+ assert 'other_lib_dir' in cmd.library_dirs
# make sure rpath is turned into a list
# if it's a string
cmd = self.build_ext(dist)
cmd.rpath = 'one%stwo' % os.pathsep
cmd.finalize_options()
- self.assertEqual(cmd.rpath, ['one', 'two'])
+ assert cmd.rpath == ['one', 'two']
# make sure cmd.link_objects is turned into a list
# if it's a string
cmd = build_ext(dist)
cmd.link_objects = 'one two,three'
cmd.finalize_options()
- self.assertEqual(cmd.link_objects, ['one', 'two', 'three'])
+ assert cmd.link_objects == ['one', 'two', 'three']
# XXX more tests to perform for win32
cmd = self.build_ext(dist)
cmd.define = 'one,two'
cmd.finalize_options()
- self.assertEqual(cmd.define, [('one', '1'), ('two', '1')])
+ assert cmd.define == [('one', '1'), ('two', '1')]
# make sure undef is turned into a list of
# strings if they are ','-separated strings
cmd = self.build_ext(dist)
cmd.undef = 'one,two'
cmd.finalize_options()
- self.assertEqual(cmd.undef, ['one', 'two'])
+ assert cmd.undef == ['one', 'two']
# make sure swig_opts is turned into a list
cmd = self.build_ext(dist)
cmd.swig_opts = None
cmd.finalize_options()
- self.assertEqual(cmd.swig_opts, [])
+ assert cmd.swig_opts == []
cmd = self.build_ext(dist)
cmd.swig_opts = '1 2'
cmd.finalize_options()
- self.assertEqual(cmd.swig_opts, ['1', '2'])
+ assert cmd.swig_opts == ['1', '2']
def test_check_extensions_list(self):
dist = Distribution()
cmd.finalize_options()
# 'extensions' option must be a list of Extension instances
- self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, 'foo')
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_extensions_list('foo')
# each element of 'ext_modules' option must be an
# Extension instance or 2-tuple
exts = [('bar', 'foo', 'bar'), 'foo']
- self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_extensions_list(exts)
# first element of each tuple in 'ext_modules'
# must be the extension name (a string) and match
# a python dotted-separated name
exts = [('foo-bar', '')]
- self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_extensions_list(exts)
# second element of each tuple in 'ext_modules'
# must be a dictionary (build info)
exts = [('foo.bar', '')]
- self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_extensions_list(exts)
# ok this one should pass
exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', 'some': 'bar'})]
cmd.check_extensions_list(exts)
ext = exts[0]
- self.assertIsInstance(ext, Extension)
+ assert isinstance(ext, Extension)
# check_extensions_list adds in ext the values passed
# when they are in ('include_dirs', 'library_dirs', 'libraries'
# 'extra_objects', 'extra_compile_args', 'extra_link_args')
- self.assertEqual(ext.libraries, 'foo')
- self.assertFalse(hasattr(ext, 'some'))
+ assert ext.libraries == 'foo'
+ assert not hasattr(ext, 'some')
# 'macros' element of build info dict must be 1- or 2-tuple
exts = [
},
)
]
- self.assertRaises(DistutilsSetupError, cmd.check_extensions_list, exts)
+ with pytest.raises(DistutilsSetupError):
+ cmd.check_extensions_list(exts)
exts[0][1]['macros'] = [('1', '2'), ('3',)]
cmd.check_extensions_list(exts)
- self.assertEqual(exts[0].undef_macros, ['3'])
- self.assertEqual(exts[0].define_macros, [('1', '2')])
+ assert exts[0].undef_macros == ['3']
+ assert exts[0].define_macros == [('1', '2')]
def test_get_source_files(self):
modules = [Extension('foo', ['xxx'], optional=False)]
dist = Distribution({'name': 'xx', 'ext_modules': modules})
cmd = self.build_ext(dist)
cmd.ensure_finalized()
- self.assertEqual(cmd.get_source_files(), ['xxx'])
+ assert cmd.get_source_files() == ['xxx']
def test_unicode_module_names(self):
modules = [
dist = Distribution({'name': 'xx', 'ext_modules': modules})
cmd = self.build_ext(dist)
cmd.ensure_finalized()
- self.assertRegex(cmd.get_ext_filename(modules[0].name), r'foo(_d)?\..*')
- self.assertRegex(cmd.get_ext_filename(modules[1].name), r'föö(_d)?\..*')
- self.assertEqual(cmd.get_export_symbols(modules[0]), ['PyInit_foo'])
- self.assertEqual(cmd.get_export_symbols(modules[1]), ['PyInitU_f_1gaa'])
+ assert re.search(r'foo(_d)?\..*', cmd.get_ext_filename(modules[0].name))
+ assert re.search(r'föö(_d)?\..*', cmd.get_ext_filename(modules[1].name))
+ assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
+ assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']
def test_compiler_option(self):
# cmd.compiler is an option and
cmd.compiler = 'unix'
cmd.ensure_finalized()
cmd.run()
- self.assertEqual(cmd.compiler, 'unix')
+ assert cmd.compiler == 'unix'
def test_get_outputs(self):
cmd = support.missing_compiler_executable()
cmd = self.build_ext(dist)
fixup_build_ext(cmd)
cmd.ensure_finalized()
- self.assertEqual(len(cmd.get_outputs()), 1)
+ assert len(cmd.get_outputs()) == 1
cmd.build_lib = os.path.join(self.tmp_dir, 'build')
cmd.build_temp = os.path.join(self.tmp_dir, 'tempt')
so_file = cmd.get_outputs()[0]
finally:
os.chdir(old_wd)
- self.assertTrue(os.path.exists(so_file))
+ assert os.path.exists(so_file)
ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
- self.assertTrue(so_file.endswith(ext_suffix))
+ assert so_file.endswith(ext_suffix)
so_dir = os.path.dirname(so_file)
- self.assertEqual(so_dir, other_tmp_dir)
+ assert so_dir == other_tmp_dir
cmd.inplace = 0
cmd.compiler = None
cmd.run()
so_file = cmd.get_outputs()[0]
- self.assertTrue(os.path.exists(so_file))
- self.assertTrue(so_file.endswith(ext_suffix))
+ assert os.path.exists(so_file)
+ assert so_file.endswith(ext_suffix)
so_dir = os.path.dirname(so_file)
- self.assertEqual(so_dir, cmd.build_lib)
+ assert so_dir == cmd.build_lib
# inplace = 0, cmd.package = 'bar'
build_py = cmd.get_finalized_command('build_py')
path = cmd.get_ext_fullpath('foo')
# checking that the last directory is the build_dir
path = os.path.split(path)[0]
- self.assertEqual(path, cmd.build_lib)
+ assert path == cmd.build_lib
# inplace = 1, cmd.package = 'bar'
cmd.inplace = 1
# checking that the last directory is bar
path = os.path.split(path)[0]
lastdir = os.path.split(path)[-1]
- self.assertEqual(lastdir, 'bar')
+ assert lastdir == 'bar'
def test_ext_fullpath(self):
ext = sysconfig.get_config_var('EXT_SUFFIX')
curdir = os.getcwd()
wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
path = cmd.get_ext_fullpath('lxml.etree')
- self.assertEqual(wanted, path)
+ assert wanted == path
# building lxml.etree not inplace
cmd.inplace = 0
cmd.build_lib = os.path.join(curdir, 'tmpdir')
wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
path = cmd.get_ext_fullpath('lxml.etree')
- self.assertEqual(wanted, path)
+ assert wanted == path
# building twisted.runner.portmap not inplace
build_py = cmd.get_finalized_command('build_py')
cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
path = cmd.get_ext_fullpath('twisted.runner.portmap')
wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext)
- self.assertEqual(wanted, path)
+ assert wanted == path
# building twisted.runner.portmap inplace
cmd.inplace = 1
path = cmd.get_ext_fullpath('twisted.runner.portmap')
wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
- self.assertEqual(wanted, path)
+ assert wanted == path
@unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+ @pytest.mark.usefixtures('save_env')
def test_deployment_target_default(self):
# Issue 9516: Test that, in the absence of the environment variable,
# an extension module is compiled with the same deployment target as
self._try_compile_deployment_target('==', None)
@unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+ @pytest.mark.usefixtures('save_env')
def test_deployment_target_too_low(self):
# Issue 9516: Test that an extension module is not allowed to be
# compiled with a deployment target less than that of the interpreter.
- self.assertRaises(
- DistutilsPlatformError, self._try_compile_deployment_target, '>', '10.1'
- )
+ with pytest.raises(DistutilsPlatformError):
+ self._try_compile_deployment_target('>', '10.1')
@unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for MacOSX')
+ @pytest.mark.usefixtures('save_env')
def test_deployment_target_higher_ok(self):
# Issue 9516: Test that an extension module can be compiled with a
# deployment target higher than that of the interpreter: the ext
self._try_compile_deployment_target('<', deptarget)
def _try_compile_deployment_target(self, operator, target):
- orig_environ = os.environ
- os.environ = orig_environ.copy()
- self.addCleanup(setattr, os, 'environ', orig_environ)
-
if target is None:
if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
del os.environ['MACOSX_DEPLOYMENT_TARGET']
deptarget_ext = Extension(
'deptarget',
[deptarget_c],
- extra_compile_args=['-DTARGET=%s' % (target,)],
+ extra_compile_args=['-DTARGET={}'.format(target)],
)
dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]})
dist.package_dir = self.tmp_dir
self.fail("Wrong deployment target during compilation")
-class ParallelBuildExtTestCase(BuildExtTestCase):
+class TestParallelBuildExt(TestBuildExt):
def build_ext(self, *args, **kwargs):
build_ext = super().build_ext(*args, **kwargs)
build_ext.parallel = True
from distutils.tests import support
-class BuildPyTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+@support.combine_markers
+class TestBuildPy(support.TempdirManager, support.LoggingSilencer):
def test_package_data(self):
sources = self.mkdtemp()
f = open(os.path.join(sources, "__init__.py"), "w")
cmd = build_py(dist)
cmd.compile = 1
cmd.ensure_finalized()
- self.assertEqual(cmd.package_data, dist.package_data)
+ assert cmd.package_data == dist.package_data
cmd.run()
# This makes sure the list of outputs includes byte-compiled
# files for Python modules but not for package data files
# (there shouldn't *be* byte-code files for those!).
- self.assertEqual(len(cmd.get_outputs()), 3)
+ assert len(cmd.get_outputs()) == 3
pkgdest = os.path.join(destination, "pkg")
files = os.listdir(pkgdest)
pycache_dir = os.path.join(pkgdest, "__pycache__")
- self.assertIn("__init__.py", files)
- self.assertIn("README.txt", files)
+ assert "__init__.py" in files
+ assert "README.txt" in files
if sys.dont_write_bytecode:
- self.assertFalse(os.path.exists(pycache_dir))
+ assert not os.path.exists(pycache_dir)
else:
pyc_files = os.listdir(pycache_dir)
- self.assertIn("__init__.%s.pyc" % sys.implementation.cache_tag, pyc_files)
+ assert "__init__.%s.pyc" % sys.implementation.cache_tag in pyc_files
def test_empty_package_dir(self):
# See bugs #1668596/#1720897
cmd.run()
found = os.listdir(cmd.build_lib)
- self.assertEqual(sorted(found), ['__pycache__', 'boiledeggs.py'])
+ assert sorted(found) == ['__pycache__', 'boiledeggs.py']
found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
- self.assertEqual(found, ['boiledeggs.%s.pyc' % sys.implementation.cache_tag])
+ assert found == ['boiledeggs.%s.pyc' % sys.implementation.cache_tag]
@unittest.skipIf(sys.dont_write_bytecode, 'byte-compile disabled')
def test_byte_compile_optimized(self):
cmd.run()
found = os.listdir(cmd.build_lib)
- self.assertEqual(sorted(found), ['__pycache__', 'boiledeggs.py'])
+ assert sorted(found) == ['__pycache__', 'boiledeggs.py']
found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
- expect = 'boiledeggs.{}.opt-1.pyc'.format(sys.implementation.cache_tag)
- self.assertEqual(sorted(found), [expect])
+ expect = f'boiledeggs.{sys.implementation.cache_tag}.opt-1.pyc'
+ assert sorted(found) == [expect]
def test_dir_in_package_data(self):
"""
finally:
sys.dont_write_bytecode = old_dont_write_bytecode
- self.assertIn('byte-compiling is disabled', self.logs[0][1] % self.logs[0][2])
+ assert 'byte-compiling is disabled' in self.logs[0][1] % self.logs[0][2]
@patch("distutils.command.build_py.log.warn")
def test_namespace_package_does_not_warn(self, log_warn):
"""Tests for distutils.command.build_scripts."""
import os
-import unittest
from distutils.command.build_scripts import build_scripts
from distutils.core import Distribution
from distutils.tests import support
-class BuildScriptsTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+class TestBuildScripts(support.TempdirManager, support.LoggingSilencer):
def test_default_settings(self):
cmd = self.get_build_scripts_cmd("/foo/bar", [])
- self.assertFalse(cmd.force)
- self.assertIsNone(cmd.build_dir)
+ assert not cmd.force
+ assert cmd.build_dir is None
cmd.finalize_options()
- self.assertTrue(cmd.force)
- self.assertEqual(cmd.build_dir, "/foo/bar")
+ assert cmd.force
+ assert cmd.build_dir == "/foo/bar"
def test_build(self):
source = self.mkdtemp()
built = os.listdir(target)
for name in expected:
- self.assertIn(name, built)
+ assert name in built
def get_build_scripts_cmd(self, target, scripts):
import sys
built = os.listdir(target)
for name in expected:
- self.assertIn(name, built)
+ assert name in built
from distutils.command.check import check, HAS_DOCUTILS
from distutils.tests import support
from distutils.errors import DistutilsSetupError
+import pytest
try:
import pygments
HERE = os.path.dirname(__file__)
-class CheckTestCase(support.LoggingSilencer, support.TempdirManager, unittest.TestCase):
+@support.combine_markers
+class TestCheck(support.LoggingSilencer, support.TempdirManager):
def _run(self, metadata=None, cwd=None, **options):
if metadata is None:
metadata = {}
# by default, check is checking the metadata
# should have some warnings
cmd = self._run()
- self.assertEqual(cmd._warnings, 1)
+ assert cmd._warnings == 1
# now let's add the required fields
# and run it again, to make sure we don't get
'version': 'xxx',
}
cmd = self._run(metadata)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
# now with the strict mode, we should
# get an error if there are missing metadata
- self.assertRaises(DistutilsSetupError, self._run, {}, **{'strict': 1})
+ with pytest.raises(DistutilsSetupError):
+ self._run({}, **{'strict': 1})
# and of course, no error when all metadata are present
cmd = self._run(metadata, strict=1)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
# now a test with non-ASCII characters
metadata = {
'long_description': 'More things about esszet \u00df',
}
cmd = self._run(metadata)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
def test_check_author_maintainer(self):
for kind in ("author", "maintainer"):
'version': 'xxx',
}
cmd = self._run(metadata)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
# the check should not warn if only email is given
metadata[kind + '_email'] = 'name@email.com'
cmd = self._run(metadata)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
# the check should not warn if only the name is given
metadata[kind] = "Name"
del metadata[kind + '_email']
cmd = self._run(metadata)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
@unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
def test_check_document(self):
# let's see if it detects broken rest
broken_rest = 'title\n===\n\ntest'
msgs = cmd._check_rst_data(broken_rest)
- self.assertEqual(len(msgs), 1)
+ assert len(msgs) == 1
# and non-broken rest
rest = 'title\n=====\n\ntest'
msgs = cmd._check_rst_data(rest)
- self.assertEqual(len(msgs), 0)
+ assert len(msgs) == 0
@unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
def test_check_restructuredtext(self):
pkg_info, dist = self.create_dist(long_description=broken_rest)
cmd = check(dist)
cmd.check_restructuredtext()
- self.assertEqual(cmd._warnings, 1)
+ assert cmd._warnings == 1
# let's see if we have an error with strict=1
metadata = {
'version': 'xxx',
'long_description': broken_rest,
}
- self.assertRaises(
- DistutilsSetupError,
- self._run,
- metadata,
- **{'strict': 1, 'restructuredtext': 1}
- )
+ with pytest.raises(DistutilsSetupError):
+ self._run(metadata, **{'strict': 1, 'restructuredtext': 1})
# and non-broken rest, including a non-ASCII character to test #12114
metadata['long_description'] = 'title\n=====\n\ntest \u00df'
cmd = self._run(metadata, strict=1, restructuredtext=1)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
# check that includes work to test #31292
metadata['long_description'] = 'title\n=====\n\n.. include:: includetest.rst'
cmd = self._run(metadata, cwd=HERE, strict=1, restructuredtext=1)
- self.assertEqual(cmd._warnings, 0)
+ assert cmd._warnings == 0
@unittest.skipUnless(HAS_DOCUTILS, "won't test without docutils")
def test_check_restructuredtext_with_syntax_highlight(self):
cmd.check_restructuredtext()
msgs = cmd._check_rst_data(rest_with_code)
if pygments is not None:
- self.assertEqual(len(msgs), 0)
+ assert len(msgs) == 0
else:
- self.assertEqual(len(msgs), 1)
- self.assertEqual(
- str(msgs[0][1]), 'Cannot analyze code. Pygments package not found.'
+ assert len(msgs) == 1
+ assert (
+ str(msgs[0][1])
+ == 'Cannot analyze code. Pygments package not found.'
)
def test_check_all(self):
- self.assertRaises(
- DistutilsSetupError, self._run, {}, **{'strict': 1, 'restructuredtext': 1}
- )
+ with pytest.raises(DistutilsSetupError):
+ self._run({}, **{'strict': 1, 'restructuredtext': 1})
"""Tests for distutils.command.clean."""
import os
-import unittest
from distutils.command.clean import clean
from distutils.tests import support
-class cleanTestCase(support.TempdirManager, support.LoggingSilencer, unittest.TestCase):
+class TestClean(support.TempdirManager, support.LoggingSilencer):
def test_simple_run(self):
pkg_dir, dist = self.create_dist()
cmd = clean(dist)
# make sure the files where removed
for name, path in dirs:
- self.assertFalse(os.path.exists(path), '%s was not removed' % path)
+ assert not os.path.exists(path), '%s was not removed' % path
# let's run the command again (should spit warnings but succeed)
cmd.all = 1
from distutils.dist import Distribution
from distutils.errors import DistutilsOptionError
from distutils import debug
+import pytest
class MyCmd(Command):
pass
-class CommandTestCase(unittest.TestCase):
+class TestCommand(unittest.TestCase):
def setUp(self):
dist = Distribution()
self.cmd = MyCmd(dist)
cmd.ensure_string_list('yes_string_list')
cmd.ensure_string_list('yes_string_list2')
- self.assertRaises(
- DistutilsOptionError, cmd.ensure_string_list, 'not_string_list'
- )
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_string_list('not_string_list')
- self.assertRaises(
- DistutilsOptionError, cmd.ensure_string_list, 'not_string_list2'
- )
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_string_list('not_string_list2')
cmd.option1 = 'ok,dok'
cmd.ensure_string_list('option1')
- self.assertEqual(cmd.option1, ['ok', 'dok'])
+ assert cmd.option1 == ['ok', 'dok']
cmd.option2 = ['xxx', 'www']
cmd.ensure_string_list('option2')
cmd.option3 = ['ok', 2]
- self.assertRaises(DistutilsOptionError, cmd.ensure_string_list, 'option3')
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_string_list('option3')
def test_make_file(self):
cmd = self.cmd
# making sure it raises when infiles is not a string or a list/tuple
- self.assertRaises(
- TypeError, cmd.make_file, infiles=1, outfile='', func='func', args=()
- )
+ with pytest.raises(TypeError):
+ cmd.make_file(infiles=1, outfile='', func='func', args=())
# making sure execute gets called properly
def _execute(func, args, exec_msg, level):
- self.assertEqual(exec_msg, 'generating out from in')
+ assert exec_msg == 'generating out from in'
cmd.force = True
cmd.execute = _execute
cmd.dump_options()
wanted = ["command options for 'MyCmd':", ' option1 = 1', ' option2 = 1']
- self.assertEqual(msgs, wanted)
+ assert msgs == wanted
def test_ensure_string(self):
cmd = self.cmd
cmd.option2 = None
cmd.ensure_string('option2', 'xxx')
- self.assertTrue(hasattr(cmd, 'option2'))
+ assert hasattr(cmd, 'option2')
cmd.option3 = 1
- self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3')
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_string('option3')
def test_ensure_filename(self):
cmd = self.cmd
cmd.option1 = __file__
cmd.ensure_filename('option1')
cmd.option2 = 'xxx'
- self.assertRaises(DistutilsOptionError, cmd.ensure_filename, 'option2')
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_filename('option2')
def test_ensure_dirname(self):
cmd = self.cmd
cmd.option1 = os.path.dirname(__file__) or os.curdir
cmd.ensure_dirname('option1')
cmd.option2 = 'xxx'
- self.assertRaises(DistutilsOptionError, cmd.ensure_dirname, 'option2')
+ with pytest.raises(DistutilsOptionError):
+ cmd.ensure_dirname('option2')
def test_debug_print(self):
cmd = self.cmd
with captured_stdout() as stdout:
cmd.debug_print('xxx')
stdout.seek(0)
- self.assertEqual(stdout.read(), '')
+ assert stdout.read() == ''
debug.DEBUG = True
try:
with captured_stdout() as stdout:
cmd.debug_print('xxx')
stdout.seek(0)
- self.assertEqual(stdout.read(), 'xxx\n')
+ assert stdout.read() == 'xxx\n'
finally:
debug.DEBUG = False
"""
+@support.combine_markers
@pytest.mark.usefixtures('save_env')
class BasePyPIRCCommandTestCase(
support.TempdirManager,
):
def setUp(self):
"""Patches the environment."""
- super(BasePyPIRCCommandTestCase, self).setUp()
+ super().setUp()
self.tmp_dir = self.mkdtemp()
os.environ['HOME'] = self.tmp_dir
os.environ['USERPROFILE'] = self.tmp_dir
def tearDown(self):
"""Removes the patch."""
set_threshold(self.old_threshold)
- super(BasePyPIRCCommandTestCase, self).tearDown()
+ super().tearDown()
class PyPIRCCommandTestCase(BasePyPIRCCommandTestCase):
('server', 'server1'),
('username', 'me'),
]
- self.assertEqual(config, waited)
+ assert config == waited
# old format
self.write_file(self.rc, PYPIRC_OLD)
('server', 'server-login'),
('username', 'tarek'),
]
- self.assertEqual(config, waited)
+ assert config == waited
def test_server_empty_registration(self):
cmd = self._cmd(self.dist)
rc = cmd._get_rc_file()
- self.assertFalse(os.path.exists(rc))
+ assert not os.path.exists(rc)
cmd._store_pypirc('tarek', 'xxx')
- self.assertTrue(os.path.exists(rc))
+ assert os.path.exists(rc)
f = open(rc)
try:
content = f.read()
- self.assertEqual(content, WANTED)
+ assert content == WANTED
finally:
f.close()
('server', 'server3'),
('username', 'cbiggles'),
]
- self.assertEqual(config, waited)
+ assert config == waited
from distutils import log
+@support.combine_markers
class ConfigTestCase(
support.LoggingSilencer, support.TempdirManager, unittest.TestCase
):
self._logs.append(line)
def setUp(self):
- super(ConfigTestCase, self).setUp()
+ super().setUp()
self._logs = []
self.old_log = log.info
log.info = self._info
def tearDown(self):
log.info = self.old_log
- super(ConfigTestCase, self).tearDown()
+ super().tearDown()
def test_dump_file(self):
this_file = os.path.splitext(__file__)[0] + '.py'
f.close()
dump_file(this_file, 'I am the header')
- self.assertEqual(len(self._logs), numlines + 1)
+ assert len(self._logs) == numlines + 1
@unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
def test_search_cpp(self):
# simple pattern searches
match = cmd.search_cpp(pattern='xxx', body='/* xxx */')
- self.assertEqual(match, 0)
+ assert match == 0
match = cmd.search_cpp(pattern='_configtest', body='/* xxx */')
- self.assertEqual(match, 1)
+ assert match == 1
def test_finalize_options(self):
# finalize_options does a bit of transformation
cmd.library_dirs = 'three%sfour' % os.pathsep
cmd.ensure_finalized()
- self.assertEqual(cmd.include_dirs, ['one', 'two'])
- self.assertEqual(cmd.libraries, ['one'])
- self.assertEqual(cmd.library_dirs, ['three', 'four'])
+ assert cmd.include_dirs == ['one', 'two']
+ assert cmd.libraries == ['one']
+ assert cmd.library_dirs == ['three', 'four']
def test_clean(self):
# _clean removes files
self.write_file(f2, 'xxx')
for f in (f1, f2):
- self.assertTrue(os.path.exists(f))
+ assert os.path.exists(f)
pkg_dir, dist = self.create_dist()
cmd = config(dist)
cmd._clean(f1, f2)
for f in (f1, f2):
- self.assertFalse(os.path.exists(f))
+ assert not os.path.exists(f)
@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
class CoreTestCase(unittest.TestCase):
def setUp(self):
- super(CoreTestCase, self).setUp()
+ super().setUp()
self.old_stdout = sys.stdout
self.cleanup_testfn()
- self.old_argv = sys.argv, sys.argv[:]
self.addCleanup(log.set_threshold, log._global_log.threshold)
def tearDown(self):
sys.stdout = self.old_stdout
self.cleanup_testfn()
- sys.argv = self.old_argv[0]
- sys.argv[:] = self.old_argv[1]
- super(CoreTestCase, self).tearDown()
+ super().tearDown()
def cleanup_testfn(self):
path = os_helper.TESTFN
# Make sure run_setup does not clobber sys.argv
argv_copy = sys.argv.copy()
distutils.core.run_setup(self.write_setup(setup_does_nothing))
- self.assertEqual(sys.argv, argv_copy)
+ assert sys.argv == argv_copy
def test_run_setup_defines_subclass(self):
# Make sure the script can use __file__; if that's missing, the test
# setup.py script will raise NameError.
dist = distutils.core.run_setup(self.write_setup(setup_defines_subclass))
install = dist.get_command_obj('install')
- self.assertIn('cmd', install.sub_commands)
+ assert 'cmd' in install.sub_commands
def test_run_setup_uses_current_dir(self):
# This tests that the setup script is run with the current directory
output = sys.stdout.getvalue()
if output.endswith("\n"):
output = output[:-1]
- self.assertEqual(cwd, output)
+ assert cwd == output
def test_run_setup_within_if_main(self):
dist = distutils.core.run_setup(
self.write_setup(setup_within_if_main), stop_after="config"
)
- self.assertIsInstance(dist, Distribution)
- self.assertEqual(dist.get_name(), "setup_within_if_main")
+ assert isinstance(dist, Distribution)
+ assert dist.get_name() == "setup_within_if_main"
def test_run_commands(self):
sys.argv = ['setup.py', 'build']
dist = distutils.core.run_setup(
self.write_setup(setup_within_if_main), stop_after="commandline"
)
- self.assertNotIn('build', dist.have_run)
+ assert 'build' not in dist.have_run
distutils.core.run_commands(dist)
- self.assertIn('build', dist.have_run)
+ assert 'build' in dist.have_run
def test_debug_mode(self):
# this covers the code called when DEBUG is set
with captured_stdout() as stdout:
distutils.core.setup(name='bar')
stdout.seek(0)
- self.assertEqual(stdout.read(), 'bar\n')
+ assert stdout.read() == 'bar\n'
distutils.core.DEBUG = True
try:
distutils.core.DEBUG = False
stdout.seek(0)
wanted = "options (after parsing config files):\n"
- self.assertEqual(stdout.readlines()[0], wanted)
+ assert stdout.readlines()[0] == wanted
get_msvcr,
)
from distutils.tests import support
+import pytest
class CygwinCCompilerTestCase(support.TempdirManager, unittest.TestCase):
def setUp(self):
- super(CygwinCCompilerTestCase, self).setUp()
+ super().setUp()
self.version = sys.version
self.python_h = os.path.join(self.mkdtemp(), 'python.h')
from distutils import sysconfig
from distutils import sysconfig
sysconfig.get_config_h_filename = self.old_get_config_h_filename
- super(CygwinCCompilerTestCase, self).tearDown()
+ super().tearDown()
def _get_config_h_filename(self):
return self.python_h
compiler = CygwinCCompiler()
link_name = "bash"
linkable_file = compiler.find_library_file(["/usr/lib"], link_name)
- self.assertIsNotNone(linkable_file)
- self.assertTrue(os.path.exists(linkable_file))
- self.assertEquals(linkable_file, "/usr/lib/lib{:s}.dll.a".format(link_name))
+ assert linkable_file is not None
+ assert os.path.exists(linkable_file)
+ assert linkable_file == f"/usr/lib/lib{link_name:s}.dll.a"
@unittest.skipIf(sys.platform != "cygwin", "Not running on Cygwin")
def test_runtime_library_dir_option(self):
from distutils.cygwinccompiler import CygwinCCompiler
compiler = CygwinCCompiler()
- self.assertEqual(compiler.runtime_library_dir_option('/foo'), [])
+ assert compiler.runtime_library_dir_option('/foo') == []
def test_check_config_h(self):
'4.0.1 (Apple Computer, Inc. build 5370)]'
)
- self.assertEqual(check_config_h()[0], CONFIG_H_OK)
+ assert check_config_h()[0] == CONFIG_H_OK
# then it tries to see if it can find "__GNUC__" in pyconfig.h
sys.version = 'something without the *CC word'
# if the file doesn't exist it returns CONFIG_H_UNCERTAIN
- self.assertEqual(check_config_h()[0], CONFIG_H_UNCERTAIN)
+ assert check_config_h()[0] == CONFIG_H_UNCERTAIN
# if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK
self.write_file(self.python_h, 'xxx')
- self.assertEqual(check_config_h()[0], CONFIG_H_NOTOK)
+ assert check_config_h()[0] == CONFIG_H_NOTOK
# and CONFIG_H_OK if __GNUC__ is found
self.write_file(self.python_h, 'xxx __GNUC__ xxx')
- self.assertEqual(check_config_h()[0], CONFIG_H_OK)
+ assert check_config_h()[0] == CONFIG_H_OK
def test_get_msvcr(self):
'2.6.1 (r261:67515, Dec 6 2008, 16:42:21) '
'\n[GCC 4.0.1 (Apple Computer, Inc. build 5370)]'
)
- self.assertEqual(get_msvcr(), None)
+ assert get_msvcr() is None
# MSVC 7.0
sys.version = (
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1300 32 bits (Intel)]'
)
- self.assertEqual(get_msvcr(), ['msvcr70'])
+ assert get_msvcr() == ['msvcr70']
# MSVC 7.1
sys.version = (
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1310 32 bits (Intel)]'
)
- self.assertEqual(get_msvcr(), ['msvcr71'])
+ assert get_msvcr() == ['msvcr71']
# VS2005 / MSVC 8.0
sys.version = (
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1400 32 bits (Intel)]'
)
- self.assertEqual(get_msvcr(), ['msvcr80'])
+ assert get_msvcr() == ['msvcr80']
# VS2008 / MSVC 9.0
sys.version = (
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1500 32 bits (Intel)]'
)
- self.assertEqual(get_msvcr(), ['msvcr90'])
+ assert get_msvcr() == ['msvcr90']
sys.version = (
'3.10.0 (tags/v3.10.0:b494f59, Oct 4 2021, 18:46:30) '
'[MSC v.1929 32 bit (Intel)]'
)
- self.assertEqual(get_msvcr(), ['ucrt', 'vcruntime140'])
+ assert get_msvcr() == ['ucrt', 'vcruntime140']
# unknown
sys.version = (
'2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.2000 32 bits (Intel)]'
)
- self.assertRaises(ValueError, get_msvcr)
+ with pytest.raises(ValueError):
+ get_msvcr()
"""Tests for distutils.dep_util."""
-import unittest
import os
from distutils.dep_util import newer, newer_pairwise, newer_group
from distutils.errors import DistutilsFileError
from distutils.tests import support
+import pytest
-class DepUtilTestCase(support.TempdirManager, unittest.TestCase):
+class TestDepUtil(support.TempdirManager):
def test_newer(self):
tmpdir = self.mkdtemp()
old_file = os.path.abspath(__file__)
# Raise DistutilsFileError if 'new_file' does not exist.
- self.assertRaises(DistutilsFileError, newer, new_file, old_file)
+ with pytest.raises(DistutilsFileError):
+ newer(new_file, old_file)
# Return true if 'new_file' exists and is more recently modified than
# 'old_file', or if 'new_file' exists and 'old_file' doesn't.
self.write_file(new_file)
- self.assertTrue(newer(new_file, 'I_dont_exist'))
- self.assertTrue(newer(new_file, old_file))
+ assert newer(new_file, 'I_dont_exist')
+ assert newer(new_file, old_file)
# Return false if both exist and 'old_file' is the same age or younger
# than 'new_file'.
- self.assertFalse(newer(old_file, new_file))
+ assert not newer(old_file, new_file)
def test_newer_pairwise(self):
tmpdir = self.mkdtemp()
self.write_file(two)
self.write_file(four)
- self.assertEqual(newer_pairwise([one, two], [three, four]), ([one], [three]))
+ assert newer_pairwise([one, two], [three, four]) == ([one], [three])
def test_newer_group(self):
tmpdir = self.mkdtemp()
self.write_file(one)
self.write_file(two)
self.write_file(three)
- self.assertTrue(newer_group([one, two, three], old_file))
- self.assertFalse(newer_group([one, two, old_file], three))
+ assert newer_group([one, two, three], old_file)
+ assert not newer_group([one, two, old_file], three)
# missing handling
os.remove(one)
- self.assertRaises(OSError, newer_group, [one, two, old_file], three)
+ with pytest.raises(OSError):
+ newer_group([one, two, old_file], three)
- self.assertFalse(newer_group([one, two, old_file], three, missing='ignore'))
+ assert not newer_group([one, two, old_file], three, missing='ignore')
- self.assertTrue(newer_group([one, two, old_file], three, missing='newer'))
+ assert newer_group([one, two, old_file], three, missing='newer')
from distutils import log
from distutils.tests import support
+import pytest
class DirUtilTestCase(support.TempdirManager, unittest.TestCase):
self._logs.append(msg)
def setUp(self):
- super(DirUtilTestCase, self).setUp()
+ super().setUp()
self._logs = []
tmp_dir = self.mkdtemp()
self.root_target = os.path.join(tmp_dir, 'deep')
def tearDown(self):
log.info = self.old_log
- super(DirUtilTestCase, self).tearDown()
+ super().tearDown()
def test_mkpath_remove_tree_verbosity(self):
mkpath(self.target, verbose=0)
wanted = []
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
remove_tree(self.root_target, verbose=0)
mkpath(self.target, verbose=1)
wanted = ['creating %s' % self.root_target, 'creating %s' % self.target]
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
self._logs = []
remove_tree(self.root_target, verbose=1)
wanted = ["removing '%s' (and everything under it)" % self.root_target]
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
@unittest.skipIf(
sys.platform.startswith('win'),
umask = os.umask(0o002)
os.umask(umask)
mkpath(self.target, 0o700)
- self.assertEqual(stat.S_IMODE(os.stat(self.target).st_mode), 0o700 & ~umask)
+ assert stat.S_IMODE(os.stat(self.target).st_mode) == 0o700 & ~umask
mkpath(self.target2, 0o555)
- self.assertEqual(stat.S_IMODE(os.stat(self.target2).st_mode), 0o555 & ~umask)
+ assert stat.S_IMODE(os.stat(self.target2).st_mode) == 0o555 & ~umask
def test_create_tree_verbosity(self):
create_tree(self.root_target, ['one', 'two', 'three'], verbose=0)
- self.assertEqual(self._logs, [])
+ assert self._logs == []
remove_tree(self.root_target, verbose=0)
wanted = ['creating %s' % self.root_target]
create_tree(self.root_target, ['one', 'two', 'three'], verbose=1)
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
remove_tree(self.root_target, verbose=0)
mkpath(self.target, verbose=0)
copy_tree(self.target, self.target2, verbose=0)
- self.assertEqual(self._logs, [])
+ assert self._logs == []
remove_tree(self.root_target, verbose=0)
with open(a_file, 'w') as f:
f.write('some content')
- wanted = ['copying %s -> %s' % (a_file, self.target2)]
+ wanted = ['copying {} -> {}'.format(a_file, self.target2)]
copy_tree(self.target, self.target2, verbose=1)
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
remove_tree(self.root_target, verbose=0)
remove_tree(self.target2, verbose=0)
fh.write('some content')
copy_tree(self.target, self.target2)
- self.assertEqual(os.listdir(self.target2), ['ok.txt'])
+ assert os.listdir(self.target2) == ['ok.txt']
remove_tree(self.root_target, verbose=0)
remove_tree(self.target2, verbose=0)
def test_ensure_relative(self):
if os.sep == '/':
- self.assertEqual(ensure_relative('/home/foo'), 'home/foo')
- self.assertEqual(ensure_relative('some/path'), 'some/path')
+ assert ensure_relative('/home/foo') == 'home/foo'
+ assert ensure_relative('some/path') == 'some/path'
else: # \\
- self.assertEqual(ensure_relative('c:\\home\\foo'), 'c:home\\foo')
- self.assertEqual(ensure_relative('home\\foo'), 'home\\foo')
+ assert ensure_relative('c:\\home\\foo') == 'c:home\\foo'
+ assert ensure_relative('home\\foo') == 'home\\foo'
def test_copy_tree_exception_in_listdir(self):
"""
An exception in listdir should raise a DistutilsFileError
"""
- with patch("os.listdir", side_effect=OSError()), self.assertRaises(
+ with patch("os.listdir", side_effect=OSError()), pytest.raises(
errors.DistutilsFileError
):
src = self.tempdirs[-1]
import unittest
import warnings
import textwrap
+import functools
from unittest import mock
return self._config_files
+@pytest.fixture
+def clear_argv():
+ del sys.argv[1:]
+
+
+@support.combine_markers
@pytest.mark.usefixtures('save_env')
-class DistributionTestCase(
+@pytest.mark.usefixtures('save_argv')
+class TestDistributionBehavior(
support.LoggingSilencer,
support.TempdirManager,
- unittest.TestCase,
):
- def setUp(self):
- super(DistributionTestCase, self).setUp()
- self.argv = sys.argv, sys.argv[:]
- del sys.argv[1:]
-
- def tearDown(self):
- sys.argv = self.argv[0]
- sys.argv[:] = self.argv[1]
- super(DistributionTestCase, self).tearDown()
-
def create_distribution(self, configfiles=()):
d = TestDistribution()
d._config_files = configfiles
d.parse_command_line()
return d
- def test_command_packages_unspecified(self):
+ def test_command_packages_unspecified(self, clear_argv):
sys.argv.append("build")
d = self.create_distribution()
- self.assertEqual(d.get_command_packages(), ["distutils.command"])
+ assert d.get_command_packages() == ["distutils.command"]
- def test_command_packages_cmdline(self):
+ def test_command_packages_cmdline(self, clear_argv):
from distutils.tests.test_dist import test_dist
sys.argv.extend(
)
d = self.create_distribution()
# let's actually try to load our test command:
- self.assertEqual(
- d.get_command_packages(),
- ["distutils.command", "foo.bar", "distutils.tests"],
- )
+ assert d.get_command_packages() == [
+ "distutils.command",
+ "foo.bar",
+ "distutils.tests",
+ ]
cmd = d.get_command_obj("test_dist")
- self.assertIsInstance(cmd, test_dist)
- self.assertEqual(cmd.sample_option, "sometext")
+ assert isinstance(cmd, test_dist)
+ assert cmd.sample_option == "sometext"
@unittest.skipIf(
'distutils' not in Distribution.parse_config_files.__module__,
'Cannot test when virtualenv has monkey-patched Distribution.',
)
- def test_venv_install_options(self):
+ def test_venv_install_options(self, request):
sys.argv.append("install")
- self.addCleanup(os.unlink, TESTFN)
+ request.addfinalizer(functools.partial(os.unlink, TESTFN))
fakepath = '/somedir'
'root': option_tuple,
}
- self.assertEqual(
- sorted(d.command_options.get('install').keys()), sorted(result_dict.keys())
+ assert sorted(d.command_options.get('install').keys()) == sorted(
+ result_dict.keys()
)
for (key, value) in d.command_options.get('install').items():
- self.assertEqual(value, result_dict[key])
+ assert value == result_dict[key]
# Test case: In a Virtual Environment
with mock.patch.multiple(sys, prefix='/a', base_prefix='/b'):
d = self.create_distribution([TESTFN])
for key in result_dict.keys():
- self.assertNotIn(key, d.command_options.get('install', {}))
+ assert key not in d.command_options.get('install', {})
- def test_command_packages_configfile(self):
+ def test_command_packages_configfile(self, request, clear_argv):
sys.argv.append("build")
- self.addCleanup(os.unlink, TESTFN)
+ request.addfinalizer(functools.partial(os.unlink, TESTFN))
f = open(TESTFN, "w")
try:
print("[global]", file=f)
f.close()
d = self.create_distribution([TESTFN])
- self.assertEqual(
- d.get_command_packages(), ["distutils.command", "foo.bar", "splat"]
- )
+ assert d.get_command_packages() == ["distutils.command", "foo.bar", "splat"]
# ensure command line overrides config:
sys.argv[1:] = ["--command-packages", "spork", "build"]
d = self.create_distribution([TESTFN])
- self.assertEqual(d.get_command_packages(), ["distutils.command", "spork"])
+ assert d.get_command_packages() == ["distutils.command", "spork"]
# Setting --command-packages to '' should cause the default to
# be used even if a config file specified something else:
sys.argv[1:] = ["--command-packages", "", "build"]
d = self.create_distribution([TESTFN])
- self.assertEqual(d.get_command_packages(), ["distutils.command"])
+ assert d.get_command_packages() == ["distutils.command"]
- def test_empty_options(self):
+ def test_empty_options(self, request):
# an empty options dictionary should not stay in the
# list of attributes
def _warn(msg):
warns.append(msg)
- self.addCleanup(setattr, warnings, 'warn', warnings.warn)
+ request.addfinalizer(
+ functools.partial(setattr, warnings, 'warn', warnings.warn)
+ )
warnings.warn = _warn
dist = Distribution(
attrs={
}
)
- self.assertEqual(len(warns), 0)
- self.assertNotIn('options', dir(dist))
+ assert len(warns) == 0
+ assert 'options' not in dir(dist)
def test_finalize_options(self):
attrs = {'keywords': 'one,two', 'platforms': 'one,two'}
dist.finalize_options()
# finalize_option splits platforms and keywords
- self.assertEqual(dist.metadata.platforms, ['one', 'two'])
- self.assertEqual(dist.metadata.keywords, ['one', 'two'])
+ assert dist.metadata.platforms == ['one', 'two']
+ assert dist.metadata.keywords == ['one', 'two']
attrs = {'keywords': 'foo bar', 'platforms': 'foo bar'}
dist = Distribution(attrs=attrs)
dist.finalize_options()
- self.assertEqual(dist.metadata.platforms, ['foo bar'])
- self.assertEqual(dist.metadata.keywords, ['foo bar'])
+ assert dist.metadata.platforms == ['foo bar']
+ assert dist.metadata.keywords == ['foo bar']
def test_get_command_packages(self):
dist = Distribution()
- self.assertEqual(dist.command_packages, None)
+ assert dist.command_packages is None
cmds = dist.get_command_packages()
- self.assertEqual(cmds, ['distutils.command'])
- self.assertEqual(dist.command_packages, ['distutils.command'])
+ assert cmds == ['distutils.command']
+ assert dist.command_packages == ['distutils.command']
dist.command_packages = 'one,two'
cmds = dist.get_command_packages()
- self.assertEqual(cmds, ['distutils.command', 'one', 'two'])
+ assert cmds == ['distutils.command', 'one', 'two']
def test_announce(self):
# make sure the level is known
dist = Distribution()
args = ('ok',)
kwargs = {'level': 'ok2'}
- self.assertRaises(ValueError, dist.announce, args, kwargs)
+ with pytest.raises(ValueError):
+ dist.announce(args, kwargs)
def test_find_config_files_disable(self):
# Ticket #1180: Allow user to disable their home config file.
os.path.expanduser = old_expander
# make sure --no-user-cfg disables the user cfg file
- self.assertEqual(len(all_files) - 1, len(files))
+ assert len(all_files) - 1 == len(files)
@pytest.mark.usefixtures('save_env')
-class MetadataTestCase(support.TempdirManager, unittest.TestCase):
- def setUp(self):
- super(MetadataTestCase, self).setUp()
- self.argv = sys.argv, sys.argv[:]
-
- def tearDown(self):
- sys.argv = self.argv[0]
- sys.argv[:] = self.argv[1]
- super(MetadataTestCase, self).tearDown()
-
+@pytest.mark.usefixtures('save_argv')
+class MetadataTestCase(support.TempdirManager):
def format_metadata(self, dist):
sio = io.StringIO()
dist.metadata.write_pkg_file(sio)
attrs = {"name": "package", "version": "1.0"}
dist = Distribution(attrs)
meta = self.format_metadata(dist)
- self.assertIn("Metadata-Version: 1.0", meta)
- self.assertNotIn("provides:", meta.lower())
- self.assertNotIn("requires:", meta.lower())
- self.assertNotIn("obsoletes:", meta.lower())
+ assert "Metadata-Version: 1.0" in meta
+ assert "provides:" not in meta.lower()
+ assert "requires:" not in meta.lower()
+ assert "obsoletes:" not in meta.lower()
def test_provides(self):
attrs = {
"provides": ["package", "package.sub"],
}
dist = Distribution(attrs)
- self.assertEqual(dist.metadata.get_provides(), ["package", "package.sub"])
- self.assertEqual(dist.get_provides(), ["package", "package.sub"])
+ assert dist.metadata.get_provides() == ["package", "package.sub"]
+ assert dist.get_provides() == ["package", "package.sub"]
meta = self.format_metadata(dist)
- self.assertIn("Metadata-Version: 1.1", meta)
- self.assertNotIn("requires:", meta.lower())
- self.assertNotIn("obsoletes:", meta.lower())
+ assert "Metadata-Version: 1.1" in meta
+ assert "requires:" not in meta.lower()
+ assert "obsoletes:" not in meta.lower()
def test_provides_illegal(self):
- self.assertRaises(
- ValueError,
- Distribution,
- {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]},
- )
+ with pytest.raises(ValueError):
+ Distribution(
+ {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]},
+ )
def test_requires(self):
attrs = {
"requires": ["other", "another (==1.0)"],
}
dist = Distribution(attrs)
- self.assertEqual(dist.metadata.get_requires(), ["other", "another (==1.0)"])
- self.assertEqual(dist.get_requires(), ["other", "another (==1.0)"])
+ assert dist.metadata.get_requires() == ["other", "another (==1.0)"]
+ assert dist.get_requires() == ["other", "another (==1.0)"]
meta = self.format_metadata(dist)
- self.assertIn("Metadata-Version: 1.1", meta)
- self.assertNotIn("provides:", meta.lower())
- self.assertIn("Requires: other", meta)
- self.assertIn("Requires: another (==1.0)", meta)
- self.assertNotIn("obsoletes:", meta.lower())
+ assert "Metadata-Version: 1.1" in meta
+ assert "provides:" not in meta.lower()
+ assert "Requires: other" in meta
+ assert "Requires: another (==1.0)" in meta
+ assert "obsoletes:" not in meta.lower()
def test_requires_illegal(self):
- self.assertRaises(
- ValueError,
- Distribution,
- {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]},
- )
+ with pytest.raises(ValueError):
+ Distribution(
+ {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]},
+ )
def test_requires_to_list(self):
attrs = {"name": "package", "requires": iter(["other"])}
dist = Distribution(attrs)
- self.assertIsInstance(dist.metadata.requires, list)
+ assert isinstance(dist.metadata.requires, list)
def test_obsoletes(self):
attrs = {
"obsoletes": ["other", "another (<1.0)"],
}
dist = Distribution(attrs)
- self.assertEqual(dist.metadata.get_obsoletes(), ["other", "another (<1.0)"])
- self.assertEqual(dist.get_obsoletes(), ["other", "another (<1.0)"])
+ assert dist.metadata.get_obsoletes() == ["other", "another (<1.0)"]
+ assert dist.get_obsoletes() == ["other", "another (<1.0)"]
meta = self.format_metadata(dist)
- self.assertIn("Metadata-Version: 1.1", meta)
- self.assertNotIn("provides:", meta.lower())
- self.assertNotIn("requires:", meta.lower())
- self.assertIn("Obsoletes: other", meta)
- self.assertIn("Obsoletes: another (<1.0)", meta)
+ assert "Metadata-Version: 1.1" in meta
+ assert "provides:" not in meta.lower()
+ assert "requires:" not in meta.lower()
+ assert "Obsoletes: other" in meta
+ assert "Obsoletes: another (<1.0)" in meta
def test_obsoletes_illegal(self):
- self.assertRaises(
- ValueError,
- Distribution,
- {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]},
- )
+ with pytest.raises(ValueError):
+ Distribution(
+ {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]},
+ )
def test_obsoletes_to_list(self):
attrs = {"name": "package", "obsoletes": iter(["other"])}
dist = Distribution(attrs)
- self.assertIsInstance(dist.metadata.obsoletes, list)
+ assert isinstance(dist.metadata.obsoletes, list)
def test_classifier(self):
attrs = {
'classifiers': ['Programming Language :: Python :: 3'],
}
dist = Distribution(attrs)
- self.assertEqual(
- dist.get_classifiers(), ['Programming Language :: Python :: 3']
- )
+ assert dist.get_classifiers() == ['Programming Language :: Python :: 3']
meta = self.format_metadata(dist)
- self.assertIn('Metadata-Version: 1.1', meta)
+ assert 'Metadata-Version: 1.1' in meta
def test_classifier_invalid_type(self):
attrs = {
with captured_stderr() as error:
d = Distribution(attrs)
# should have warning about passing a non-list
- self.assertIn('should be a list', error.getvalue())
+ assert 'should be a list' in error.getvalue()
# should be converted to a list
- self.assertIsInstance(d.metadata.classifiers, list)
- self.assertEqual(d.metadata.classifiers, list(attrs['classifiers']))
+ assert isinstance(d.metadata.classifiers, list)
+ assert d.metadata.classifiers == list(attrs['classifiers'])
def test_keywords(self):
attrs = {
'keywords': ['spam', 'eggs', 'life of brian'],
}
dist = Distribution(attrs)
- self.assertEqual(dist.get_keywords(), ['spam', 'eggs', 'life of brian'])
+ assert dist.get_keywords() == ['spam', 'eggs', 'life of brian']
def test_keywords_invalid_type(self):
attrs = {
with captured_stderr() as error:
d = Distribution(attrs)
# should have warning about passing a non-list
- self.assertIn('should be a list', error.getvalue())
+ assert 'should be a list' in error.getvalue()
# should be converted to a list
- self.assertIsInstance(d.metadata.keywords, list)
- self.assertEqual(d.metadata.keywords, list(attrs['keywords']))
+ assert isinstance(d.metadata.keywords, list)
+ assert d.metadata.keywords == list(attrs['keywords'])
def test_platforms(self):
attrs = {
'platforms': ['GNU/Linux', 'Some Evil Platform'],
}
dist = Distribution(attrs)
- self.assertEqual(dist.get_platforms(), ['GNU/Linux', 'Some Evil Platform'])
+ assert dist.get_platforms() == ['GNU/Linux', 'Some Evil Platform']
def test_platforms_invalid_types(self):
attrs = {
with captured_stderr() as error:
d = Distribution(attrs)
# should have warning about passing a non-list
- self.assertIn('should be a list', error.getvalue())
+ assert 'should be a list' in error.getvalue()
# should be converted to a list
- self.assertIsInstance(d.metadata.platforms, list)
- self.assertEqual(d.metadata.platforms, list(attrs['platforms']))
+ assert isinstance(d.metadata.platforms, list)
+ assert d.metadata.platforms == list(attrs['platforms'])
def test_download_url(self):
attrs = {
}
dist = Distribution(attrs)
meta = self.format_metadata(dist)
- self.assertIn('Metadata-Version: 1.1', meta)
+ assert 'Metadata-Version: 1.1' in meta
def test_long_description(self):
long_desc = textwrap.dedent(
dist = Distribution(attrs)
meta = self.format_metadata(dist)
meta = meta.replace('\n' + 8 * ' ', '\n')
- self.assertIn(long_desc, meta)
+ assert long_desc in meta
def test_custom_pydistutils(self):
# fixes #2166
if sys.platform in ('linux', 'darwin'):
os.environ['HOME'] = temp_dir
files = dist.find_config_files()
- self.assertIn(user_filename, files)
+ assert user_filename in files
# win32-style
if sys.platform == 'win32':
# home drive should be found
os.environ['USERPROFILE'] = temp_dir
files = dist.find_config_files()
- self.assertIn(
- user_filename, files, '%r not found in %r' % (user_filename, files)
+ assert user_filename in files, '{!r} not found in {!r}'.format(
+ user_filename, files
)
finally:
os.remove(user_filename)
def test_fix_help_options(self):
help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
fancy_options = fix_help_options(help_tuples)
- self.assertEqual(fancy_options[0], ('a', 'b', 'c'))
- self.assertEqual(fancy_options[1], (1, 2, 3))
+ assert fancy_options[0] == ('a', 'b', 'c')
+ assert fancy_options[1] == (1, 2, 3)
def test_show_help(self):
# smoke test, just makes sure some help is displayed
dist.parse_command_line()
output = [line for line in s.getvalue().split('\n') if line.strip() != '']
- self.assertTrue(output)
+ assert output
def test_read_metadata(self):
attrs = {
PKG_INFO.seek(0)
metadata.read_pkg_file(PKG_INFO)
- self.assertEqual(metadata.name, "package")
- self.assertEqual(metadata.version, "1.0")
- self.assertEqual(metadata.description, "xxx")
- self.assertEqual(metadata.download_url, 'http://example.com')
- self.assertEqual(metadata.keywords, ['one', 'two'])
- self.assertEqual(metadata.platforms, None)
- self.assertEqual(metadata.obsoletes, None)
- self.assertEqual(metadata.requires, ['foo'])
+ assert metadata.name == "package"
+ assert metadata.version == "1.0"
+ assert metadata.description == "xxx"
+ assert metadata.download_url == 'http://example.com'
+ assert metadata.keywords == ['one', 'two']
+ assert metadata.platforms is None
+ assert metadata.obsoletes is None
+ assert metadata.requires == ['foo']
"""Tests for distutils.extension."""
-import unittest
import os
import warnings
from distutils.extension import read_setup_file, Extension
from .py38compat import check_warnings
+import pytest
-class ExtensionTestCase(unittest.TestCase):
+class TestExtension:
def test_read_setup_file(self):
# trying to read a Setup file
# (sample extracted from the PyGame project)
'transform',
]
- self.assertEqual(names, wanted)
+ assert names == wanted
def test_extension_init(self):
# the first argument, which is the name, must be a string
- self.assertRaises(AssertionError, Extension, 1, [])
+ with pytest.raises(AssertionError):
+ Extension(1, [])
ext = Extension('name', [])
- self.assertEqual(ext.name, 'name')
+ assert ext.name == 'name'
# the second argument, which is the list of files, must
# be a list of strings
- self.assertRaises(AssertionError, Extension, 'name', 'file')
- self.assertRaises(AssertionError, Extension, 'name', ['file', 1])
+ with pytest.raises(AssertionError):
+ Extension('name', 'file')
+ with pytest.raises(AssertionError):
+ Extension('name', ['file', 1])
ext = Extension('name', ['file1', 'file2'])
- self.assertEqual(ext.sources, ['file1', 'file2'])
+ assert ext.sources == ['file1', 'file2']
# others arguments have defaults
for attr in (
'swig_opts',
'depends',
):
- self.assertEqual(getattr(ext, attr), [])
+ assert getattr(ext, attr) == []
- self.assertEqual(ext.language, None)
- self.assertEqual(ext.optional, None)
+ assert ext.language is None
+ assert ext.optional is None
# if there are unknown keyword options, warn about them
with check_warnings() as w:
warnings.simplefilter('always')
ext = Extension('name', ['file1', 'file2'], chic=True)
- self.assertEqual(len(w.warnings), 1)
- self.assertEqual(
- str(w.warnings[0].message), "Unknown Extension options: 'chic'"
- )
+ assert len(w.warnings) == 1
+ assert str(w.warnings[0].message) == "Unknown Extension options: 'chic'"
from distutils.tests import support
from distutils.errors import DistutilsFileError
from .py38compat import unlink
+import pytest
class FileUtilTestCase(support.TempdirManager, unittest.TestCase):
self._logs.append(msg)
def setUp(self):
- super(FileUtilTestCase, self).setUp()
+ super().setUp()
self._logs = []
self.old_log = log.info
log.info = self._log
def tearDown(self):
log.info = self.old_log
- super(FileUtilTestCase, self).tearDown()
+ super().tearDown()
def test_move_file_verbosity(self):
f = open(self.source, 'w')
move_file(self.source, self.target, verbose=0)
wanted = []
- self.assertEqual(self._logs, wanted)
+ assert self._logs == wanted
# back to original state
move_file(self.target, self.source, verbose=0)
move_file(self.source, self.target, verbose=1)
- wanted = ['moving %s -> %s' % (self.source, self.target)]
- self.assertEqual(self._logs, wanted)
+ wanted = ['moving {} -> {}'.format(self.source, self.target)]
+ assert self._logs == wanted
# back to original state
move_file(self.target, self.source, verbose=0)
# now the target is a dir
os.mkdir(self.target_dir)
move_file(self.source, self.target_dir, verbose=1)
- wanted = ['moving %s -> %s' % (self.source, self.target_dir)]
- self.assertEqual(self._logs, wanted)
+ wanted = ['moving {} -> {}'.format(self.source, self.target_dir)]
+ assert self._logs == wanted
def test_move_file_exception_unpacking_rename(self):
# see issue 22182
- with patch("os.rename", side_effect=OSError("wrong", 1)), self.assertRaises(
+ with patch("os.rename", side_effect=OSError("wrong", 1)), pytest.raises(
DistutilsFileError
):
with open(self.source, 'w') as fobj:
# see issue 22182
with patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")), patch(
"os.unlink", side_effect=OSError("wrong", 1)
- ), self.assertRaises(DistutilsFileError):
+ ), pytest.raises(DistutilsFileError):
with open(self.source, 'w') as fobj:
fobj.write('spam eggs')
move_file(self.source, self.target, verbose=0)
copy_file(self.source, self.target, link='hard')
st2 = os.stat(self.source)
st3 = os.stat(self.target)
- self.assertTrue(os.path.samestat(st, st2), (st, st2))
- self.assertTrue(os.path.samestat(st2, st3), (st2, st3))
- with open(self.source, 'r') as f:
- self.assertEqual(f.read(), 'some content')
+ assert os.path.samestat(st, st2), (st, st2)
+ assert os.path.samestat(st2, st3), (st2, st3)
+ with open(self.source) as f:
+ assert f.read() == 'some content'
def test_copy_file_hard_link_failure(self):
# If hard linking fails, copy_file() falls back on copying file
copy_file(self.source, self.target, link='hard')
st2 = os.stat(self.source)
st3 = os.stat(self.target)
- self.assertTrue(os.path.samestat(st, st2), (st, st2))
- self.assertFalse(os.path.samestat(st2, st3), (st2, st3))
+ assert os.path.samestat(st, st2), (st, st2)
+ assert not os.path.samestat(st2, st3), (st2, st3)
for fn in (self.source, self.target):
- with open(fn, 'r') as f:
- self.assertEqual(f.read(), 'some content')
+ with open(fn) as f:
+ assert f.read() == 'some content'
"""Tests for distutils.filelist."""
import os
import re
-import unittest
from distutils import debug
from distutils.log import WARN
from distutils.errors import DistutilsTemplateError
from distutils.tests import support
from . import py38compat as os_helper
+import pytest
MANIFEST_IN = """\
return s.replace('/', os.sep)
-class FileListTestCase(support.LoggingSilencer, unittest.TestCase):
+class TestFileList(support.LoggingSilencer):
def assertNoWarnings(self):
- self.assertEqual(self.get_logs(WARN), [])
+ assert self.get_logs(WARN) == []
self.clear_logs()
def assertWarnings(self):
- self.assertGreater(len(self.get_logs(WARN)), 0)
+ assert len(self.get_logs(WARN)) > 0
self.clear_logs()
def test_glob_to_re(self):
(r'foo\\??', r'(?s:foo\\\\[^%(sep)s][^%(sep)s])\Z'),
):
regex = regex % {'sep': sep}
- self.assertEqual(glob_to_re(glob), regex)
+ assert glob_to_re(glob) == regex
def test_process_template_line(self):
# testing all MANIFEST.in template patterns
mlp('dir/dir2/graft2'),
]
- self.assertEqual(file_list.files, wanted)
+ assert file_list.files == wanted
def test_debug_print(self):
file_list = FileList()
with captured_stdout() as stdout:
file_list.debug_print('xxx')
- self.assertEqual(stdout.getvalue(), '')
+ assert stdout.getvalue() == ''
debug.DEBUG = True
try:
with captured_stdout() as stdout:
file_list.debug_print('xxx')
- self.assertEqual(stdout.getvalue(), 'xxx\n')
+ assert stdout.getvalue() == 'xxx\n'
finally:
debug.DEBUG = False
file_list = FileList()
files = ['a', 'b', 'c']
file_list.set_allfiles(files)
- self.assertEqual(file_list.allfiles, files)
+ assert file_list.allfiles == files
def test_remove_duplicates(self):
file_list = FileList()
# files must be sorted beforehand (sdist does it)
file_list.sort()
file_list.remove_duplicates()
- self.assertEqual(file_list.files, ['a', 'b', 'c', 'g'])
+ assert file_list.files == ['a', 'b', 'c', 'g']
def test_translate_pattern(self):
# not regex
- self.assertTrue(
- hasattr(translate_pattern('a', anchor=True, is_regex=False), 'search')
- )
+ assert hasattr(translate_pattern('a', anchor=True, is_regex=False), 'search')
# is a regex
regex = re.compile('a')
- self.assertEqual(translate_pattern(regex, anchor=True, is_regex=True), regex)
+ assert translate_pattern(regex, anchor=True, is_regex=True) == regex
# plain string flagged as regex
- self.assertTrue(
- hasattr(translate_pattern('a', anchor=True, is_regex=True), 'search')
- )
+ assert hasattr(translate_pattern('a', anchor=True, is_regex=True), 'search')
# glob support
- self.assertTrue(
- translate_pattern('*.py', anchor=True, is_regex=False).search('filelist.py')
+ assert translate_pattern('*.py', anchor=True, is_regex=False).search(
+ 'filelist.py'
)
def test_exclude_pattern(self):
# return False if no match
file_list = FileList()
- self.assertFalse(file_list.exclude_pattern('*.py'))
+ assert not file_list.exclude_pattern('*.py')
# return True if files match
file_list = FileList()
file_list.files = ['a.py', 'b.py']
- self.assertTrue(file_list.exclude_pattern('*.py'))
+ assert file_list.exclude_pattern('*.py')
# test excludes
file_list = FileList()
file_list.files = ['a.py', 'a.txt']
file_list.exclude_pattern('*.py')
- self.assertEqual(file_list.files, ['a.txt'])
+ assert file_list.files == ['a.txt']
def test_include_pattern(self):
# return False if no match
file_list = FileList()
file_list.set_allfiles([])
- self.assertFalse(file_list.include_pattern('*.py'))
+ assert not file_list.include_pattern('*.py')
# return True if files match
file_list = FileList()
file_list.set_allfiles(['a.py', 'b.txt'])
- self.assertTrue(file_list.include_pattern('*.py'))
+ assert file_list.include_pattern('*.py')
# test * matches all files
file_list = FileList()
- self.assertIsNone(file_list.allfiles)
+ assert file_list.allfiles is None
file_list.set_allfiles(['a.py', 'b.txt'])
file_list.include_pattern('*')
- self.assertEqual(file_list.allfiles, ['a.py', 'b.txt'])
+ assert file_list.allfiles == ['a.py', 'b.txt']
def test_process_template(self):
mlp = make_local_path
'prune',
'blarg',
):
- self.assertRaises(
- DistutilsTemplateError, file_list.process_template_line, action
- )
+ with pytest.raises(DistutilsTemplateError):
+ file_list.process_template_line(action)
# include
file_list = FileList()
file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])
file_list.process_template_line('include *.py')
- self.assertEqual(file_list.files, ['a.py'])
+ assert file_list.files == ['a.py']
self.assertNoWarnings()
file_list.process_template_line('include *.rb')
- self.assertEqual(file_list.files, ['a.py'])
+ assert file_list.files == ['a.py']
self.assertWarnings()
# exclude
file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]
file_list.process_template_line('exclude *.py')
- self.assertEqual(file_list.files, ['b.txt', mlp('d/c.py')])
+ assert file_list.files == ['b.txt', mlp('d/c.py')]
self.assertNoWarnings()
file_list.process_template_line('exclude *.rb')
- self.assertEqual(file_list.files, ['b.txt', mlp('d/c.py')])
+ assert file_list.files == ['b.txt', mlp('d/c.py')]
self.assertWarnings()
# global-include
file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])
file_list.process_template_line('global-include *.py')
- self.assertEqual(file_list.files, ['a.py', mlp('d/c.py')])
+ assert file_list.files == ['a.py', mlp('d/c.py')]
self.assertNoWarnings()
file_list.process_template_line('global-include *.rb')
- self.assertEqual(file_list.files, ['a.py', mlp('d/c.py')])
+ assert file_list.files == ['a.py', mlp('d/c.py')]
self.assertWarnings()
# global-exclude
file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]
file_list.process_template_line('global-exclude *.py')
- self.assertEqual(file_list.files, ['b.txt'])
+ assert file_list.files == ['b.txt']
self.assertNoWarnings()
file_list.process_template_line('global-exclude *.rb')
- self.assertEqual(file_list.files, ['b.txt'])
+ assert file_list.files == ['b.txt']
self.assertWarnings()
# recursive-include
file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')])
file_list.process_template_line('recursive-include d *.py')
- self.assertEqual(file_list.files, [mlp('d/b.py'), mlp('d/d/e.py')])
+ assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
self.assertNoWarnings()
file_list.process_template_line('recursive-include e *.py')
- self.assertEqual(file_list.files, [mlp('d/b.py'), mlp('d/d/e.py')])
+ assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
self.assertWarnings()
# recursive-exclude
file_list.files = ['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')]
file_list.process_template_line('recursive-exclude d *.py')
- self.assertEqual(file_list.files, ['a.py', mlp('d/c.txt')])
+ assert file_list.files == ['a.py', mlp('d/c.txt')]
self.assertNoWarnings()
file_list.process_template_line('recursive-exclude e *.py')
- self.assertEqual(file_list.files, ['a.py', mlp('d/c.txt')])
+ assert file_list.files == ['a.py', mlp('d/c.txt')]
self.assertWarnings()
# graft
file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')])
file_list.process_template_line('graft d')
- self.assertEqual(file_list.files, [mlp('d/b.py'), mlp('d/d/e.py')])
+ assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
self.assertNoWarnings()
file_list.process_template_line('graft e')
- self.assertEqual(file_list.files, [mlp('d/b.py'), mlp('d/d/e.py')])
+ assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
self.assertWarnings()
# prune
file_list.files = ['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')]
file_list.process_template_line('prune d')
- self.assertEqual(file_list.files, ['a.py', mlp('f/f.py')])
+ assert file_list.files == ['a.py', mlp('f/f.py')]
self.assertNoWarnings()
file_list.process_template_line('prune e')
- self.assertEqual(file_list.files, ['a.py', mlp('f/f.py')])
+ assert file_list.files == ['a.py', mlp('f/f.py')]
self.assertWarnings()
-class FindAllTestCase(unittest.TestCase):
+class TestFindAll:
@os_helper.skip_unless_symlink
def test_missing_symlink(self):
with os_helper.temp_cwd():
os.symlink('foo', 'bar')
- self.assertEqual(filelist.findall(), [])
+ assert filelist.findall() == []
def test_basic_discovery(self):
"""
file2 = os.path.join('bar', 'file2.txt')
os_helper.create_empty_file(file2)
expected = [file2, file1]
- self.assertEqual(sorted(filelist.findall()), expected)
+ assert sorted(filelist.findall()) == expected
def test_non_local_discovery(self):
"""
file1 = os.path.join(temp_dir, 'file1.txt')
os_helper.create_empty_file(file1)
expected = [file1]
- self.assertEqual(filelist.findall(temp_dir), expected)
+ assert filelist.findall(temp_dir) == expected
@os_helper.skip_unless_symlink
def test_symlink_loop(self):
return modname + sysconfig.get_config_var('EXT_SUFFIX')
+@support.combine_markers
@pytest.mark.usefixtures('save_env')
class InstallTestCase(
support.TempdirManager,
cmd.home = destination
cmd.ensure_finalized()
- self.assertEqual(cmd.install_base, destination)
- self.assertEqual(cmd.install_platbase, destination)
+ assert cmd.install_base == destination
+ assert cmd.install_platbase == destination
def check_path(got, expected):
got = os.path.normpath(got)
expected = os.path.normpath(expected)
- self.assertEqual(got, expected)
+ assert got == expected
impl_name = sys.implementation.name.replace("cpython", "python")
libdir = os.path.join(destination, "lib", impl_name)
self.addCleanup(cleanup)
for key in ('nt_user', 'posix_user'):
- self.assertIn(key, INSTALL_SCHEMES)
+ assert key in INSTALL_SCHEMES
dist = Distribution({'name': 'xx'})
cmd = install(dist)
# making sure the user option is there
options = [name for name, short, lable in cmd.user_options]
- self.assertIn('user', options)
+ assert 'user' in options
# setting a value
cmd.user = 1
# user base and site shouldn't be created yet
- self.assertFalse(os.path.exists(self.user_base))
- self.assertFalse(os.path.exists(self.user_site))
+ assert not os.path.exists(self.user_base)
+ assert not os.path.exists(self.user_site)
# let's run finalize
cmd.ensure_finalized()
# now they should
- self.assertTrue(os.path.exists(self.user_base))
- self.assertTrue(os.path.exists(self.user_site))
+ assert os.path.exists(self.user_base)
+ assert os.path.exists(self.user_site)
- self.assertIn('userbase', cmd.config_vars)
- self.assertIn('usersite', cmd.config_vars)
+ assert 'userbase' in cmd.config_vars
+ assert 'usersite' in cmd.config_vars
actual_headers = os.path.relpath(cmd.install_headers, self.user_base)
if os.name == 'nt':
include = sysconfig.get_python_inc(0, '')
expect_headers = os.path.join(include, 'xx')
- self.assertEqual(
- os.path.normcase(actual_headers), os.path.normcase(expect_headers)
- )
+ assert os.path.normcase(actual_headers) == os.path.normcase(expect_headers)
def test_handle_extra_path(self):
dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
# two elements
cmd.handle_extra_path()
- self.assertEqual(cmd.extra_path, ['path', 'dirs'])
- self.assertEqual(cmd.extra_dirs, 'dirs')
- self.assertEqual(cmd.path_file, 'path')
+ assert cmd.extra_path == ['path', 'dirs']
+ assert cmd.extra_dirs == 'dirs'
+ assert cmd.path_file == 'path'
# one element
cmd.extra_path = ['path']
cmd.handle_extra_path()
- self.assertEqual(cmd.extra_path, ['path'])
- self.assertEqual(cmd.extra_dirs, 'path')
- self.assertEqual(cmd.path_file, 'path')
+ assert cmd.extra_path == ['path']
+ assert cmd.extra_dirs == 'path'
+ assert cmd.path_file == 'path'
# none
dist.extra_path = cmd.extra_path = None
cmd.handle_extra_path()
- self.assertEqual(cmd.extra_path, None)
- self.assertEqual(cmd.extra_dirs, '')
- self.assertEqual(cmd.path_file, None)
+ assert cmd.extra_path is None
+ assert cmd.extra_dirs == ''
+ assert cmd.path_file is None
# three elements (no way !)
cmd.extra_path = 'path,dirs,again'
- self.assertRaises(DistutilsOptionError, cmd.handle_extra_path)
+ with pytest.raises(DistutilsOptionError):
+ cmd.handle_extra_path()
def test_finalize_options(self):
dist = Distribution({'name': 'xx'})
# install-base/install-platbase -- not both
cmd.prefix = 'prefix'
cmd.install_base = 'base'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
# must supply either home or prefix/exec-prefix -- not both
cmd.install_base = None
cmd.home = 'home'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
# can't combine user with prefix/exec_prefix/home or
# install_(plat)base
cmd.prefix = None
cmd.user = 'user'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
def test_record(self):
install_dir = self.mkdtemp()
'sayhi',
'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2],
]
- self.assertEqual(found, expected)
+ assert found == expected
def test_record_extensions(self):
cmd = test_support.missing_compiler_executable()
_make_ext_name('xx'),
'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2],
]
- self.assertEqual(found, expected)
+ assert found == expected
def test_debug_mode(self):
# this covers the code called when DEBUG is set
self.test_record()
finally:
install_module.DEBUG = False
- self.assertGreater(len(self.logs), old_logs_len)
+ assert len(self.logs) > old_logs_len
"""Tests for distutils.command.install_data."""
import os
-import unittest
import pytest
@pytest.mark.usefixtures('save_env')
-class InstallDataTestCase(
+class TestInstallData(
support.TempdirManager,
support.LoggingSilencer,
- unittest.TestCase,
):
def test_simple_run(self):
pkg_dir, dist = self.create_dist()
self.write_file(two, 'xxx')
cmd.data_files = [one, (inst2, [two])]
- self.assertEqual(cmd.get_inputs(), [one, (inst2, [two])])
+ assert cmd.get_inputs() == [one, (inst2, [two])]
# let's run the command
cmd.ensure_finalized()
cmd.run()
# let's check the result
- self.assertEqual(len(cmd.get_outputs()), 2)
+ assert len(cmd.get_outputs()) == 2
rtwo = os.path.split(two)[-1]
- self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
+ assert os.path.exists(os.path.join(inst2, rtwo))
rone = os.path.split(one)[-1]
- self.assertTrue(os.path.exists(os.path.join(inst, rone)))
+ assert os.path.exists(os.path.join(inst, rone))
cmd.outfiles = []
# let's try with warn_dir one
cmd.run()
# let's check the result
- self.assertEqual(len(cmd.get_outputs()), 2)
- self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
- self.assertTrue(os.path.exists(os.path.join(inst, rone)))
+ assert len(cmd.get_outputs()) == 2
+ assert os.path.exists(os.path.join(inst2, rtwo))
+ assert os.path.exists(os.path.join(inst, rone))
cmd.outfiles = []
# now using root and empty dir
cmd.run()
# let's check the result
- self.assertEqual(len(cmd.get_outputs()), 4)
- self.assertTrue(os.path.exists(os.path.join(inst2, rtwo)))
- self.assertTrue(os.path.exists(os.path.join(inst, rone)))
+ assert len(cmd.get_outputs()) == 4
+ assert os.path.exists(os.path.join(inst2, rtwo))
+ assert os.path.exists(os.path.join(inst, rone))
"""Tests for distutils.command.install_headers."""
import os
-import unittest
import pytest
@pytest.mark.usefixtures('save_env')
-class InstallHeadersTestCase(
+class TestInstallHeaders(
support.TempdirManager,
support.LoggingSilencer,
- unittest.TestCase,
):
def test_simple_run(self):
# we have two headers
pkg_dir, dist = self.create_dist(headers=headers)
cmd = install_headers(dist)
- self.assertEqual(cmd.get_inputs(), headers)
+ assert cmd.get_inputs() == headers
# let's run the command
cmd.install_dir = os.path.join(pkg_dir, 'inst')
cmd.run()
# let's check the results
- self.assertEqual(len(cmd.get_outputs()), 2)
+ assert len(cmd.get_outputs()) == 2
from distutils.errors import DistutilsOptionError
+@support.combine_markers
@pytest.mark.usefixtures('save_env')
-class InstallLibTestCase(
+class TestInstallLib(
support.TempdirManager,
support.LoggingSilencer,
- unittest.TestCase,
):
def test_finalize_options(self):
dist = self.create_dist()[1]
cmd = install_lib(dist)
cmd.finalize_options()
- self.assertEqual(cmd.compile, 1)
- self.assertEqual(cmd.optimize, 0)
+ assert cmd.compile == 1
+ assert cmd.optimize == 0
# optimize must be 0, 1, or 2
cmd.optimize = 'foo'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
cmd.optimize = '4'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
cmd.optimize = '2'
cmd.finalize_options()
- self.assertEqual(cmd.optimize, 2)
+ assert cmd.optimize == 2
@unittest.skipIf(sys.dont_write_bytecode, 'byte-compile disabled')
def test_byte_compile(self):
pyc_opt_file = importlib.util.cache_from_source(
'foo.py', optimization=cmd.optimize
)
- self.assertTrue(os.path.exists(pyc_file))
- self.assertTrue(os.path.exists(pyc_opt_file))
+ assert os.path.exists(pyc_file)
+ assert os.path.exists(pyc_opt_file)
def test_get_outputs(self):
project_dir, dist = self.create_dist()
# get_outputs should return 4 elements: spam/__init__.py and .pyc,
# foo.import-tag-abiflags.so / foo.pyd
outputs = cmd.get_outputs()
- self.assertEqual(len(outputs), 4, outputs)
+ assert len(outputs) == 4, outputs
def test_get_inputs(self):
project_dir, dist = self.create_dist()
# get_inputs should return 2 elements: spam/__init__.py and
# foo.import-tag-abiflags.so / foo.pyd
inputs = cmd.get_inputs()
- self.assertEqual(len(inputs), 2, inputs)
+ assert len(inputs) == 2, inputs
def test_dont_write_bytecode(self):
# makes sure byte_compile is not used
finally:
sys.dont_write_bytecode = old_dont_write_bytecode
- self.assertIn('byte-compiling is disabled', self.logs[0][1] % self.logs[0][2])
+ assert 'byte-compiling is disabled' in self.logs[0][1] % self.logs[0][2]
"""Tests for distutils.command.install_scripts."""
import os
-import unittest
from distutils.command.install_scripts import install_scripts
from distutils.core import Distribution
from distutils.tests import support
-class InstallScriptsTestCase(
- support.TempdirManager, support.LoggingSilencer, unittest.TestCase
-):
+class TestInstallScripts(support.TempdirManager, support.LoggingSilencer):
def test_default_settings(self):
dist = Distribution()
dist.command_obj["build"] = support.DummyCommand(build_scripts="/foo/bar")
skip_build=1,
)
cmd = install_scripts(dist)
- self.assertFalse(cmd.force)
- self.assertFalse(cmd.skip_build)
- self.assertIsNone(cmd.build_dir)
- self.assertIsNone(cmd.install_dir)
+ assert not cmd.force
+ assert not cmd.skip_build
+ assert cmd.build_dir is None
+ assert cmd.install_dir is None
cmd.finalize_options()
- self.assertTrue(cmd.force)
- self.assertTrue(cmd.skip_build)
- self.assertEqual(cmd.build_dir, "/foo/bar")
- self.assertEqual(cmd.install_dir, "/splat/funk")
+ assert cmd.force
+ assert cmd.skip_build
+ assert cmd.build_dir == "/foo/bar"
+ assert cmd.install_dir == "/splat/funk"
def test_installation(self):
source = self.mkdtemp()
installed = os.listdir(target)
for name in expected:
- self.assertIn(name, installed)
+ assert name in installed
log.set_threshold(old_threshold)
stdout.seek(0)
- self.assertEqual(
- stdout.read().rstrip(),
+ assert stdout.read().rstrip() == (
'Dεbug\tM?ss?ge'
if errors == 'replace'
else 'Dεbug\tMssge'
if errors == 'ignore'
- else 'Dεbug\tM\\u0117ss\\xe3ge',
+ else 'Dεbug\tM\\u0117ss\\xe3ge'
)
stderr.seek(0)
- self.assertEqual(
- stderr.read().rstrip(),
+ assert stderr.read().rstrip() == (
'Fαtal\t?rr?r'
if errors == 'replace'
else 'Fαtal\trrr'
if errors == 'ignore'
- else 'Fαtal\t\\xc8rr\\u014dr',
+ else 'Fαtal\t\\xc8rr\\u014dr'
)
"""Tests for distutils.msvc9compiler."""
import sys
-import unittest
import os
from distutils.errors import DistutilsPlatformError
from distutils.tests import support
+import pytest
# A manifest with the only assembly reference being the msvcrt assembly, so
# should have the assembly completely stripped. Note that although the
SKIP_MESSAGE = "These tests are only for win32"
-@unittest.skipUnless(SKIP_MESSAGE is None, SKIP_MESSAGE)
-class msvc9compilerTestCase(support.TempdirManager, unittest.TestCase):
+@pytest.mark.skipif('SKIP_MESSAGE', reason=SKIP_MESSAGE)
+class Testmsvc9compiler(support.TempdirManager):
def test_no_compiler(self):
# makes sure query_vcvarsall raises
# a DistutilsPlatformError if the compiler
old_find_vcvarsall = msvc9compiler.find_vcvarsall
msvc9compiler.find_vcvarsall = _find_vcvarsall
try:
- self.assertRaises(
- DistutilsPlatformError, query_vcvarsall, 'wont find this version'
- )
+ with pytest.raises(DistutilsPlatformError):
+ query_vcvarsall('wont find this version')
finally:
msvc9compiler.find_vcvarsall = old_find_vcvarsall
def test_reg_class(self):
from distutils.msvc9compiler import Reg
- self.assertRaises(KeyError, Reg.get_value, 'xxx', 'xxx')
+ with pytest.raises(KeyError):
+ Reg.get_value('xxx', 'xxx')
# looking for values that should exist on all
# windows registry versions.
path = r'Control Panel\Desktop'
v = Reg.get_value(path, 'dragfullwindows')
- self.assertIn(v, ('0', '1', '2'))
+ assert v in ('0', '1', '2')
import winreg
HKCU = winreg.HKEY_CURRENT_USER
keys = Reg.read_keys(HKCU, 'xxxx')
- self.assertEqual(keys, None)
+ assert keys is None
keys = Reg.read_keys(HKCU, r'Control Panel')
- self.assertIn('Desktop', keys)
+ assert 'Desktop' in keys
def test_remove_visual_c_ref(self):
from distutils.msvc9compiler import MSVCCompiler
f.close()
# makes sure the manifest was properly cleaned
- self.assertEqual(content, _CLEANED_MANIFEST)
+ assert content == _CLEANED_MANIFEST
def test_remove_entire_manifest(self):
from distutils.msvc9compiler import MSVCCompiler
compiler = MSVCCompiler()
got = compiler._remove_visual_c_ref(manifest)
- self.assertIsNone(got)
+ assert got is None
needs_winreg = pytest.mark.skipif('not hasattr(_msvccompiler, "winreg")')
-class msvccompilerTestCase(support.TempdirManager, unittest.TestCase):
+class Testmsvccompiler(support.TempdirManager):
def test_no_compiler(self):
# makes sure query_vcvarsall raises
# a DistutilsPlatformError if the compiler
old_find_vcvarsall = _msvccompiler._find_vcvarsall
_msvccompiler._find_vcvarsall = _find_vcvarsall
try:
- self.assertRaises(
- DistutilsPlatformError,
- _msvccompiler._get_vc_env,
- 'wont find this version',
- )
+ with pytest.raises(DistutilsPlatformError):
+ _msvccompiler._get_vc_env(
+ 'wont find this version',
+ )
finally:
_msvccompiler._find_vcvarsall = old_find_vcvarsall
os.environ[test_var] = test_value
try:
env = _msvccompiler._get_vc_env('x86')
- self.assertIn(test_var.lower(), env)
- self.assertEqual(test_value, env[test_var.lower()])
+ assert test_var.lower() in env
+ assert test_value == env[test_var.lower()]
finally:
os.environ.pop(test_var)
if old_distutils_use_sdk:
# and mark it skipped if we do not.
version, path = _msvccompiler._find_vc2017()
if version:
- self.assertGreaterEqual(version, 15)
- self.assertTrue(os.path.isdir(path))
+ assert version >= 15
+ assert os.path.isdir(path)
else:
raise unittest.SkipTest("VS 2017 is not installed")
# and mark it skipped if we do not.
version, path = _msvccompiler._find_vc2015()
if version:
- self.assertGreaterEqual(version, 14)
- self.assertTrue(os.path.isdir(path))
+ assert version >= 14
+ assert os.path.isdir(path)
else:
raise unittest.SkipTest("VS 2015 is not installed")
return not self.exc_info
-class TestSpawn(unittest.TestCase):
+class TestSpawn:
def test_concurrent_safe(self):
"""
Concurrent calls to spawn should have consistent results.
from distutils.log import INFO
from distutils.tests.test_config import BasePyPIRCCommandTestCase
+import pytest
try:
import docutils
"""
-class Inputs(object):
+class Inputs:
"""Fakes user inputs."""
def __init__(self, *answers):
self.index += 1
-class FakeOpener(object):
+class FakeOpener:
"""Fakes a PyPI server"""
def __init__(self):
class RegisterTestCase(BasePyPIRCCommandTestCase):
def setUp(self):
- super(RegisterTestCase, self).setUp()
+ super().setUp()
# patching the password prompt
self._old_getpass = getpass.getpass
getpass.getpass = self._old_getpass
urllib.request._opener = None
urllib.request.build_opener = self.old_opener
- super(RegisterTestCase, self).tearDown()
+ super().tearDown()
def _get_cmd(self, metadata=None):
if metadata is None:
cmd = self._get_cmd()
# we shouldn't have a .pypirc file yet
- self.assertFalse(os.path.exists(self.rc))
+ assert not os.path.exists(self.rc)
# patching input and getpass.getpass
# so register gets happy
del register_module.input
# we should have a brand new .pypirc file
- self.assertTrue(os.path.exists(self.rc))
+ assert os.path.exists(self.rc)
# with the content similar to WANTED_PYPIRC
f = open(self.rc)
try:
content = f.read()
- self.assertEqual(content, WANTED_PYPIRC)
+ assert content == WANTED_PYPIRC
finally:
f.close()
# let's see what the server received : we should
# have 2 similar requests
- self.assertEqual(len(self.conn.reqs), 2)
+ assert len(self.conn.reqs) == 2
req1 = dict(self.conn.reqs[0].headers)
req2 = dict(self.conn.reqs[1].headers)
- self.assertEqual(req1['Content-length'], '1359')
- self.assertEqual(req2['Content-length'], '1359')
- self.assertIn(b'xxx', self.conn.reqs[1].data)
+ assert req1['Content-length'] == '1359'
+ assert req2['Content-length'] == '1359'
+ assert b'xxx' in self.conn.reqs[1].data
def test_password_not_in_file(self):
# dist.password should be set
# therefore used afterwards by other commands
- self.assertEqual(cmd.distribution.password, 'password')
+ assert cmd.distribution.password == 'password'
def test_registering(self):
# this test runs choice 2
del register_module.input
# we should have send a request
- self.assertEqual(len(self.conn.reqs), 1)
+ assert len(self.conn.reqs) == 1
req = self.conn.reqs[0]
headers = dict(req.headers)
- self.assertEqual(headers['Content-length'], '608')
- self.assertIn(b'tarek', req.data)
+ assert headers['Content-length'] == '608'
+ assert b'tarek' in req.data
def test_password_reset(self):
# this test runs choice 3
del register_module.input
# we should have send a request
- self.assertEqual(len(self.conn.reqs), 1)
+ assert len(self.conn.reqs) == 1
req = self.conn.reqs[0]
headers = dict(req.headers)
- self.assertEqual(headers['Content-length'], '290')
- self.assertIn(b'tarek', req.data)
+ assert headers['Content-length'] == '290'
+ assert b'tarek' in req.data
@unittest.skipUnless(docutils is not None, 'needs docutils')
def test_strict(self):
cmd = self._get_cmd({})
cmd.ensure_finalized()
cmd.strict = 1
- self.assertRaises(DistutilsSetupError, cmd.run)
+ with pytest.raises(DistutilsSetupError):
+ cmd.run()
# metadata are OK but long_description is broken
metadata = {
cmd = self._get_cmd(metadata)
cmd.ensure_finalized()
cmd.strict = 1
- self.assertRaises(DistutilsSetupError, cmd.run)
+ with pytest.raises(DistutilsSetupError):
+ cmd.run()
# now something that works
metadata['long_description'] = 'title\n=====\n\ntext'
register_module.input = inputs
self.addCleanup(delattr, register_module, 'input')
- self.assertRaises(DistutilsSetupError, cmd.run)
+ with pytest.raises(DistutilsSetupError):
+ cmd.run()
def test_check_metadata_deprecated(self):
# makes sure make_metadata is deprecated
with check_warnings() as w:
warnings.simplefilter("always")
cmd.check_metadata()
- self.assertEqual(len(w.warnings), 1)
+ assert len(w.warnings) == 1
def test_list_classifiers(self):
cmd = self._get_cmd()
cmd.list_classifiers = 1
cmd.run()
results = self.get_logs(INFO)
- self.assertEqual(results, ['running check', 'xxx'])
+ assert results == ['running check', 'xxx']
def test_show_response(self):
# test that the --show-response option return a well formatted response
del register_module.input
results = self.get_logs(INFO)
- self.assertEqual(results[3], 75 * '-' + '\nxxx\n' + 75 * '-')
+ assert results[3] == 75 * '-' + '\nxxx\n' + 75 * '-'
def setUp(self):
# PyPIRCCommandTestCase creates a temp dir already
# and put it in self.tmp_dir
- super(SDistTestCase, self).setUp()
+ super().setUp()
# setting up an environment
self.old_path = os.getcwd()
os.mkdir(join(self.tmp_dir, 'somecode'))
def tearDown(self):
# back to normal
os.chdir(self.old_path)
- super(SDistTestCase, self).tearDown()
+ super().tearDown()
def get_cmd(self, metadata=None):
"""Returns a cmd"""
# now let's check what we have
dist_folder = join(self.tmp_dir, 'dist')
files = os.listdir(dist_folder)
- self.assertEqual(files, ['fake-1.0.zip'])
+ assert files == ['fake-1.0.zip']
zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
try:
'somecode/',
'somecode/__init__.py',
]
- self.assertEqual(sorted(content), ['fake-1.0/' + x for x in expected])
+ assert sorted(content) == ['fake-1.0/' + x for x in expected]
@pytest.mark.usefixtures('needs_zlib')
@unittest.skipIf(find_executable('tar') is None, "The tar command is not found")
dist_folder = join(self.tmp_dir, 'dist')
result = os.listdir(dist_folder)
result.sort()
- self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])
+ assert result == ['fake-1.0.tar', 'fake-1.0.tar.gz']
os.remove(join(dist_folder, 'fake-1.0.tar'))
os.remove(join(dist_folder, 'fake-1.0.tar.gz'))
result = os.listdir(dist_folder)
result.sort()
- self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'])
+ assert result == ['fake-1.0.tar', 'fake-1.0.tar.gz']
@pytest.mark.usefixtures('needs_zlib')
def test_add_defaults(self):
# now let's check what we have
dist_folder = join(self.tmp_dir, 'dist')
files = os.listdir(dist_folder)
- self.assertEqual(files, ['fake-1.0.zip'])
+ assert files == ['fake-1.0.zip']
zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
try:
'somecode/doc.dat',
'somecode/doc.txt',
]
- self.assertEqual(sorted(content), ['fake-1.0/' + x for x in expected])
+ assert sorted(content) == ['fake-1.0/' + x for x in expected]
# checking the MANIFEST
f = open(join(self.tmp_dir, 'MANIFEST'))
manifest = f.read()
finally:
f.close()
- self.assertEqual(manifest, MANIFEST % {'sep': os.sep})
+ assert manifest == MANIFEST % {'sep': os.sep}
@pytest.mark.usefixtures('needs_zlib')
def test_metadata_check_option(self):
warnings = [
msg for msg in self.get_logs(WARN) if msg.startswith('warning: check:')
]
- self.assertEqual(len(warnings), 1)
+ assert len(warnings) == 1
# trying with a complete set of metadata
self.clear_logs()
warnings = [
msg for msg in self.get_logs(WARN) if msg.startswith('warning: check:')
]
- self.assertEqual(len(warnings), 0)
+ assert len(warnings) == 0
def test_check_metadata_deprecated(self):
# makes sure make_metadata is deprecated
with check_warnings() as w:
warnings.simplefilter("always")
cmd.check_metadata()
- self.assertEqual(len(w.warnings), 1)
+ assert len(w.warnings) == 1
def test_show_formats(self):
with captured_stdout() as stdout:
for line in stdout.getvalue().split('\n')
if line.strip().startswith('--formats=')
]
- self.assertEqual(len(output), num_formats)
+ assert len(output) == num_formats
def test_finalize_options(self):
dist, cmd = self.get_cmd()
cmd.finalize_options()
# default options set by finalize
- self.assertEqual(cmd.manifest, 'MANIFEST')
- self.assertEqual(cmd.template, 'MANIFEST.in')
- self.assertEqual(cmd.dist_dir, 'dist')
+ assert cmd.manifest == 'MANIFEST'
+ assert cmd.template == 'MANIFEST.in'
+ assert cmd.dist_dir == 'dist'
# formats has to be a string splitable on (' ', ',') or
# a stringlist
cmd.formats = 1
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
cmd.formats = ['zip']
cmd.finalize_options()
# formats has to be known
cmd.formats = 'supazipa'
- self.assertRaises(DistutilsOptionError, cmd.finalize_options)
+ with pytest.raises(DistutilsOptionError):
+ cmd.finalize_options()
# the following tests make sure there is a nice error message instead
# of a traceback when parsing an invalid manifest template
cmd.filelist = FileList()
cmd.read_template()
warnings = self.get_logs(WARN)
- self.assertEqual(len(warnings), 1)
+ assert len(warnings) == 1
def test_invalid_template_unknown_command(self):
self._check_template('taunt knights *')
finally:
f.close()
- self.assertEqual(len(manifest), 5)
+ assert len(manifest) == 5
# adding a file
self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')
f.close()
# do we have the new file in MANIFEST ?
- self.assertEqual(len(manifest2), 6)
- self.assertIn('doc2.txt', manifest2[-1])
+ assert len(manifest2) == 6
+ assert 'doc2.txt' in manifest2[-1]
@pytest.mark.usefixtures('needs_zlib')
def test_manifest_marker(self):
finally:
f.close()
- self.assertEqual(manifest[0], '# file GENERATED by distutils, do NOT edit')
+ assert manifest[0] == '# file GENERATED by distutils, do NOT edit'
@pytest.mark.usefixtures('needs_zlib')
def test_manifest_comments(self):
self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!")
self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!")
cmd.run()
- self.assertEqual(cmd.filelist.files, ['good.py'])
+ assert cmd.filelist.files == ['good.py']
@pytest.mark.usefixtures('needs_zlib')
def test_manual_manifest(self):
'This project maintains its MANIFEST file itself.',
)
cmd.run()
- self.assertEqual(cmd.filelist.files, ['README.manual'])
+ assert cmd.filelist.files == ['README.manual']
f = open(cmd.manifest)
try:
finally:
f.close()
- self.assertEqual(manifest, ['README.manual'])
+ assert manifest == ['README.manual']
archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
archive = tarfile.open(archive_name)
filenames = [tarinfo.name for tarinfo in archive]
finally:
archive.close()
- self.assertEqual(
- sorted(filenames),
- ['fake-1.0', 'fake-1.0/PKG-INFO', 'fake-1.0/README.manual'],
- )
+ assert sorted(filenames) == [
+ 'fake-1.0',
+ 'fake-1.0/PKG-INFO',
+ 'fake-1.0/README.manual',
+ ]
@pytest.mark.usefixtures('needs_zlib')
@require_unix_id
archive = tarfile.open(archive_name)
try:
for member in archive.getmembers():
- self.assertEqual(member.uid, 0)
- self.assertEqual(member.gid, 0)
+ assert member.uid == 0
+ assert member.gid == 0
finally:
archive.close()
# rights (see #7408)
try:
for member in archive.getmembers():
- self.assertEqual(member.uid, os.getuid())
+ assert member.uid == os.getuid()
finally:
archive.close()
from distutils.spawn import spawn
from distutils.errors import DistutilsExecError
from distutils.tests import support
+import pytest
-class SpawnTestCase(support.TempdirManager, support.LoggingSilencer, unittest.TestCase):
+class TestSpawn(support.TempdirManager, support.LoggingSilencer):
@unittest.skipUnless(os.name in ('nt', 'posix'), 'Runs only under posix or nt')
def test_spawn(self):
tmpdir = self.mkdtemp()
self.write_file(exe, 'exit 1')
os.chmod(exe, 0o777)
- self.assertRaises(DistutilsExecError, spawn, [exe])
+ with pytest.raises(DistutilsExecError):
+ spawn([exe])
# now something that works
if sys.platform != 'win32':
# test path parameter
rv = find_executable(program, path=tmp_dir)
- self.assertEqual(rv, filename)
+ assert rv == filename
if sys.platform == 'win32':
# test without ".exe" extension
rv = find_executable(program_noeext, path=tmp_dir)
- self.assertEqual(rv, filename)
+ assert rv == filename
# test find in the current directory
with os_helper.change_cwd(tmp_dir):
rv = find_executable(program)
- self.assertEqual(rv, program)
+ assert rv == program
# test non-existent program
dont_exist_program = "dontexist_" + program
rv = find_executable(dont_exist_program, path=tmp_dir)
- self.assertIsNone(rv)
+ assert rv is None
# PATH='': no match, except in the current directory
with os_helper.EnvironmentVarGuard() as env:
'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
), unittest.mock.patch('distutils.spawn.os.defpath', tmp_dir):
rv = find_executable(program)
- self.assertIsNone(rv)
+ assert rv is None
# look in current directory
with os_helper.change_cwd(tmp_dir):
rv = find_executable(program)
- self.assertEqual(rv, program)
+ assert rv == program
# PATH=':': explicitly looks in the current directory
with os_helper.EnvironmentVarGuard() as env:
'distutils.spawn.os.confstr', return_value='', create=True
), unittest.mock.patch('distutils.spawn.os.defpath', ''):
rv = find_executable(program)
- self.assertIsNone(rv)
+ assert rv is None
# look in current directory
with os_helper.change_cwd(tmp_dir):
rv = find_executable(program)
- self.assertEqual(rv, program)
+ assert rv == program
# missing PATH: test os.confstr("CS_PATH") and os.defpath
with os_helper.EnvironmentVarGuard() as env:
'distutils.spawn.os.confstr', side_effect=ValueError, create=True
), unittest.mock.patch('distutils.spawn.os.defpath', tmp_dir):
rv = find_executable(program)
- self.assertEqual(rv, filename)
+ assert rv == filename
# with confstr
with unittest.mock.patch(
'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
), unittest.mock.patch('distutils.spawn.os.defpath', ''):
rv = find_executable(program)
- self.assertEqual(rv, filename)
+ assert rv == filename
def test_spawn_missing_exe(self):
- with self.assertRaises(DistutilsExecError) as ctx:
+ with pytest.raises(DistutilsExecError) as ctx:
spawn(['does-not-exist'])
- self.assertIn("command 'does-not-exist' failed", str(ctx.exception))
+ assert "command 'does-not-exist' failed" in str(ctx.value)
@pytest.mark.usefixtures('save_env')
class SysconfigTestCase(unittest.TestCase):
def setUp(self):
- super(SysconfigTestCase, self).setUp()
+ super().setUp()
self.makefile = None
def tearDown(self):
if self.makefile is not None:
os.unlink(self.makefile)
self.cleanup_testfn()
- super(SysconfigTestCase, self).tearDown()
+ super().tearDown()
def cleanup_testfn(self):
if os.path.isfile(TESTFN):
def test_get_config_h_filename(self):
config_h = sysconfig.get_config_h_filename()
- self.assertTrue(os.path.isfile(config_h), config_h)
+ assert os.path.isfile(config_h), config_h
@unittest.skipIf(
sys.platform == 'win32', 'Makefile only exists on Unix like systems'
)
def test_get_makefile_filename(self):
makefile = sysconfig.get_makefile_filename()
- self.assertTrue(os.path.isfile(makefile), makefile)
+ assert os.path.isfile(makefile), makefile
def test_get_python_lib(self):
# XXX doesn't work on Linux when Python was never installed before
# self.assertTrue(os.path.isdir(lib_dir), lib_dir)
# test for pythonxx.lib?
- self.assertNotEqual(
- sysconfig.get_python_lib(), sysconfig.get_python_lib(prefix=TESTFN)
- )
+ assert sysconfig.get_python_lib() != sysconfig.get_python_lib(prefix=TESTFN)
def test_get_config_vars(self):
cvars = sysconfig.get_config_vars()
- self.assertIsInstance(cvars, dict)
- self.assertTrue(cvars)
+ assert isinstance(cvars, dict)
+ assert cvars
@unittest.skip('sysconfig.IS_PYPY')
def test_srcdir(self):
# See Issues #15322, #15364.
srcdir = sysconfig.get_config_var('srcdir')
- self.assertTrue(os.path.isabs(srcdir), srcdir)
- self.assertTrue(os.path.isdir(srcdir), srcdir)
+ assert os.path.isabs(srcdir), srcdir
+ assert os.path.isdir(srcdir), srcdir
if sysconfig.python_build:
# The python executable has not been installed so srcdir
# should be a full source checkout.
Python_h = os.path.join(srcdir, 'Include', 'Python.h')
- self.assertTrue(os.path.exists(Python_h), Python_h)
- self.assertTrue(sysconfig._is_python_source_dir(srcdir))
+ assert os.path.exists(Python_h), Python_h
+ assert sysconfig._is_python_source_dir(srcdir)
elif os.name == 'posix':
- self.assertEqual(os.path.dirname(sysconfig.get_makefile_filename()), srcdir)
+ assert os.path.dirname(sysconfig.get_makefile_filename()) == srcdir
def test_srcdir_independent_of_cwd(self):
# srcdir should be independent of the current working directory
srcdir2 = sysconfig.get_config_var('srcdir')
finally:
os.chdir(cwd)
- self.assertEqual(srcdir, srcdir2)
+ assert srcdir == srcdir2
def customize_compiler(self):
# make sure AR gets caught
os.environ['RANLIB'] = 'env_ranlib'
comp = self.customize_compiler()
- self.assertEqual(comp.exes['archiver'], 'env_ar --env-arflags')
- self.assertEqual(comp.exes['preprocessor'], 'env_cpp --env-cppflags')
- self.assertEqual(
- comp.exes['compiler'], 'env_cc --sc-cflags --env-cflags --env-cppflags'
- )
- self.assertEqual(
- comp.exes['compiler_so'],
- ('env_cc --sc-cflags ' '--env-cflags ' '--env-cppflags --sc-ccshared'),
+ assert comp.exes['archiver'] == 'env_ar --env-arflags'
+ assert comp.exes['preprocessor'] == 'env_cpp --env-cppflags'
+ assert comp.exes['compiler'] == 'env_cc --sc-cflags --env-cflags --env-cppflags'
+ assert comp.exes['compiler_so'] == (
+ 'env_cc --sc-cflags ' '--env-cflags ' '--env-cppflags --sc-ccshared'
)
- self.assertEqual(comp.exes['compiler_cxx'], 'env_cxx --env-cxx-flags')
- self.assertEqual(comp.exes['linker_exe'], 'env_cc')
- self.assertEqual(
- comp.exes['linker_so'],
- ('env_ldshared --env-ldflags --env-cflags' ' --env-cppflags'),
+ assert comp.exes['compiler_cxx'] == 'env_cxx --env-cxx-flags'
+ assert comp.exes['linker_exe'] == 'env_cc'
+ assert comp.exes['linker_so'] == (
+ 'env_ldshared --env-ldflags --env-cflags' ' --env-cppflags'
)
- self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
+ assert comp.shared_lib_extension == 'sc_shutil_suffix'
if sys.platform == "darwin":
- self.assertEqual(comp.exes['ranlib'], 'env_ranlib')
+ assert comp.exes['ranlib'] == 'env_ranlib'
else:
- self.assertTrue('ranlib' not in comp.exes)
+ assert 'ranlib' not in comp.exes
del os.environ['AR']
del os.environ['CC']
del os.environ['RANLIB']
comp = self.customize_compiler()
- self.assertEqual(comp.exes['archiver'], 'sc_ar --sc-arflags')
- self.assertEqual(comp.exes['preprocessor'], 'sc_cc -E')
- self.assertEqual(comp.exes['compiler'], 'sc_cc --sc-cflags')
- self.assertEqual(comp.exes['compiler_so'], 'sc_cc --sc-cflags --sc-ccshared')
- self.assertEqual(comp.exes['compiler_cxx'], 'sc_cxx')
- self.assertEqual(comp.exes['linker_exe'], 'sc_cc')
- self.assertEqual(comp.exes['linker_so'], 'sc_ldshared')
- self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
- self.assertTrue('ranlib' not in comp.exes)
+ assert comp.exes['archiver'] == 'sc_ar --sc-arflags'
+ assert comp.exes['preprocessor'] == 'sc_cc -E'
+ assert comp.exes['compiler'] == 'sc_cc --sc-cflags'
+ assert comp.exes['compiler_so'] == 'sc_cc --sc-cflags --sc-ccshared'
+ assert comp.exes['compiler_cxx'] == 'sc_cxx'
+ assert comp.exes['linker_exe'] == 'sc_cc'
+ assert comp.exes['linker_so'] == 'sc_ldshared'
+ assert comp.shared_lib_extension == 'sc_shutil_suffix'
+ assert 'ranlib' not in comp.exes
def test_parse_makefile_base(self):
self.makefile = TESTFN
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
- self.assertEqual(
- d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'}
- )
+ assert d == {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'}
def test_parse_makefile_literal_dollar(self):
self.makefile = TESTFN
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
- self.assertEqual(
- d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'}
- )
+ assert d == {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'}
def test_sysconfig_module(self):
import sysconfig as global_sysconfig
- self.assertEqual(
- global_sysconfig.get_config_var('CFLAGS'),
- sysconfig.get_config_var('CFLAGS'),
+ assert global_sysconfig.get_config_var('CFLAGS') == sysconfig.get_config_var(
+ 'CFLAGS'
)
- self.assertEqual(
- global_sysconfig.get_config_var('LDFLAGS'),
- sysconfig.get_config_var('LDFLAGS'),
+ assert global_sysconfig.get_config_var('LDFLAGS') == sysconfig.get_config_var(
+ 'LDFLAGS'
)
@unittest.skipIf(
if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
self.skipTest('compiler flags customized')
- self.assertEqual(
- global_sysconfig.get_config_var('LDSHARED'),
- sysconfig.get_config_var('LDSHARED'),
- )
- self.assertEqual(
- global_sysconfig.get_config_var('CC'), sysconfig.get_config_var('CC')
+ assert global_sysconfig.get_config_var('LDSHARED') == sysconfig.get_config_var(
+ 'LDSHARED'
)
+ assert global_sysconfig.get_config_var('CC') == sysconfig.get_config_var('CC')
@unittest.skipIf(
sysconfig.get_config_var('EXT_SUFFIX') is None,
'EXT_SUFFIX required for this test',
)
def test_SO_deprecation(self):
- self.assertWarns(DeprecationWarning, sysconfig.get_config_var, 'SO')
+ with pytest.warns(DeprecationWarning):
+ sysconfig.get_config_var('SO')
def test_customize_compiler_before_get_config_vars(self):
# Issue #21923: test that a Distribution compiler
universal_newlines=True,
)
outs, errs = p.communicate()
- self.assertEqual(0, p.returncode, "Subprocess failed: " + outs)
+ assert 0 == p.returncode, "Subprocess failed: " + outs
def test_parse_config_h(self):
config_h = sysconfig.get_config_h_filename()
input = {}
with open(config_h, encoding="utf-8") as f:
result = sysconfig.parse_config_h(f, g=input)
- self.assertTrue(input is result)
+ assert input is result
with open(config_h, encoding="utf-8") as f:
result = sysconfig.parse_config_h(f)
- self.assertTrue(isinstance(result, dict))
+ assert isinstance(result, dict)
@unittest.skipUnless(sys.platform == 'win32', 'Testing windows pyd suffix')
@unittest.skipUnless(
sys.implementation.name == 'cpython', 'Need cpython for this test'
)
def test_win_ext_suffix(self):
- self.assertTrue(sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd"))
- self.assertNotEqual(sysconfig.get_config_var("EXT_SUFFIX"), ".pyd")
+ assert sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd")
+ assert sysconfig.get_config_var("EXT_SUFFIX") != ".pyd"
@unittest.skipUnless(sys.platform == 'win32', 'Testing Windows build layout')
@unittest.skipUnless(
"""Tests for distutils.text_file."""
import os
-import unittest
from distutils.text_file import TextFile
from distutils.tests import support
"""
-class TextFileTestCase(support.TempdirManager, unittest.TestCase):
+class TestTextFile(support.TempdirManager):
def test_class(self):
# old tests moved from text_file.__main__
# so they are really called by the buildbots
def test_input(count, description, file, expected_result):
result = file.readlines()
- self.assertEqual(result, expected_result)
+ assert result == expected_result
tmpdir = self.mkdtemp()
filename = os.path.join(tmpdir, "test.txt")
from distutils.util import _clear_cached_macosx_ver
from . import support
+import pytest
class UnixCCompilerTestCase(support.TempdirManager, unittest.TestCase):
def do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag):
env = os.environ
- msg = "macOS version = (sysconfig=%r, env=%r)" % (
+ msg = "macOS version = (sysconfig={!r}, env={!r})".format(
syscfg_macosx_ver,
env_macosx_ver,
)
# Run the test
if expected_flag is not None:
- self.assertEqual(self.cc.rpath_foo(), expected_flag, msg=msg)
+ assert self.cc.rpath_foo() == expected_flag, msg
else:
- with self.assertRaisesRegex(
- DistutilsPlatformError, darwin_ver_var + r' mismatch', msg=msg
+ with pytest.raises(
+ DistutilsPlatformError, match=darwin_ver_var + r' mismatch'
):
self.cc.rpath_foo()
return 'xxx'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), ['+s', '-L/foo'])
+ assert self.cc.rpath_foo() == ['+s', '-L/foo']
def gcv(v):
return 'gcc'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])
+ assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']
def gcv(v):
return 'g++'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])
+ assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']
sysconfig.get_config_var = old_gcv
return 'yes'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'
def gcv(v):
if v == 'CC':
return 'yes'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'
# GCC non-GNULD
sys.platform = 'bar'
return 'no'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,-R/foo'
# GCC GNULD with fully qualified configuration prefix
# see #7617
return 'yes'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'
# non-GCC GNULD
sys.platform = 'bar'
return 'yes'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'
# non-GCC non-GNULD
sys.platform = 'bar'
return 'no'
sysconfig.get_config_var = gcv
- self.assertEqual(self.cc.rpath_foo(), '-Wl,-R/foo')
+ assert self.cc.rpath_foo() == '-Wl,-R/foo'
@unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
def test_cc_overrides_ldshared(self):
env['CC'] = 'my_cc'
del env['LDSHARED']
sysconfig.customize_compiler(self.cc)
- self.assertEqual(self.cc.linker_so[0], 'my_cc')
+ assert self.cc.linker_so[0] == 'my_cc'
@unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
def test_cc_overrides_ldshared_for_cxx_correctly(self):
env['CXX'] = 'my_cxx'
del env['LDSHARED']
sysconfig.customize_compiler(self.cc)
- self.assertEqual(self.cc.linker_so[0:2], ['ccache', 'my_cc'])
+ assert self.cc.linker_so[0:2] == ['ccache', 'my_cc']
self.cc.link(None, [], 'a.out', target_lang='c++')
call_args = mock_spawn.call_args[0][0]
expected = ['my_cxx', '-bundle', '-undefined', 'dynamic_lookup']
env['CC'] = 'my_cc'
env['LDSHARED'] = 'my_ld -bundle -dynamic'
sysconfig.customize_compiler(self.cc)
- self.assertEqual(self.cc.linker_so[0], 'my_ld')
+ assert self.cc.linker_so[0] == 'my_ld'
def test_has_function(self):
# Issue https://github.com/pypa/distutils/issues/64:
from distutils.log import ERROR, INFO
from distutils.tests.test_config import PYPIRC, BasePyPIRCCommandTestCase
+import pytest
PYPIRC_LONG_PASSWORD = """\
[distutils]
"""
-class FakeOpen(object):
+class FakeOpen:
def __init__(self, url, msg=None, code=None):
self.url = url
if not isinstance(url, str):
class uploadTestCase(BasePyPIRCCommandTestCase):
def setUp(self):
- super(uploadTestCase, self).setUp()
+ super().setUp()
self.old_open = upload_mod.urlopen
upload_mod.urlopen = self._urlopen
self.last_open = None
def tearDown(self):
upload_mod.urlopen = self.old_open
- super(uploadTestCase, self).tearDown()
+ super().tearDown()
def _urlopen(self, url):
self.last_open = FakeOpen(url, msg=self.next_msg, code=self.next_code)
('realm', 'pypi'),
('repository', 'https://upload.pypi.org/legacy/'),
):
- self.assertEqual(getattr(cmd, attr), waited)
+ assert getattr(cmd, attr) == waited
def test_saved_password(self):
# file with no password
dist = Distribution()
cmd = upload(dist)
cmd.finalize_options()
- self.assertEqual(cmd.password, None)
+ assert cmd.password is None
# make sure we get it as well, if another command
# initialized it at the dist level
dist.password = 'xxx'
cmd = upload(dist)
cmd.finalize_options()
- self.assertEqual(cmd.password, 'xxx')
+ assert cmd.password == 'xxx'
def test_upload(self):
tmp = self.mkdtemp()
# what did we send ?
headers = dict(self.last_open.req.headers)
- self.assertGreaterEqual(int(headers['Content-length']), 2162)
+ assert int(headers['Content-length']) >= 2162
content_type = headers['Content-type']
- self.assertTrue(content_type.startswith('multipart/form-data'))
- self.assertEqual(self.last_open.req.get_method(), 'POST')
+ assert content_type.startswith('multipart/form-data')
+ assert self.last_open.req.get_method() == 'POST'
expected_url = 'https://upload.pypi.org/legacy/'
- self.assertEqual(self.last_open.req.get_full_url(), expected_url)
+ assert self.last_open.req.get_full_url() == expected_url
data = self.last_open.req.data
- self.assertIn(b'xxx', data)
- self.assertIn(b'protocol_version', data)
- self.assertIn(b'sha256_digest', data)
- self.assertIn(
- b'cd2eb0837c9b4c962c22d2ff8b5441b7b45805887f051d39bf133b583baf' b'6860',
- data,
+ assert b'xxx' in data
+ assert b'protocol_version' in data
+ assert b'sha256_digest' in data
+ assert (
+ b'cd2eb0837c9b4c962c22d2ff8b5441b7b45805887f051d39bf133b583baf'
+ b'6860' in data
)
if b'md5_digest' in data:
- self.assertIn(b'f561aaf6ef0bf14d4208bb46a4ccb3ad', data)
+ assert b'f561aaf6ef0bf14d4208bb46a4ccb3ad' in data
if b'blake2_256_digest' in data:
- self.assertIn(
+ assert (
b'b6f289a27d4fe90da63c503bfe0a9b761a8f76bb86148565065f040be'
b'6d1c3044cf7ded78ef800509bccb4b648e507d88dc6383d67642aadcc'
- b'ce443f1534330a',
- data,
+ b'ce443f1534330a' in data
)
# The PyPI response body was echoed
results = self.get_logs(INFO)
- self.assertEqual(results[-1], 75 * '-' + '\nxyzzy\n' + 75 * '-')
+ assert results[-1] == 75 * '-' + '\nxyzzy\n' + 75 * '-'
# bpo-32304: archives whose last byte was b'\r' were corrupted due to
# normalization intended for Mac OS 9.
cmd.run()
headers = dict(self.last_open.req.headers)
- self.assertGreaterEqual(int(headers['Content-length']), 2172)
- self.assertIn(b'long description\r', self.last_open.req.data)
+ assert int(headers['Content-length']) >= 2172
+ assert b'long description\r' in self.last_open.req.data
def test_upload_fails(self):
self.next_msg = "Not Found"
self.next_code = 404
- self.assertRaises(DistutilsError, self.test_upload)
+ with pytest.raises(DistutilsError):
+ self.test_upload()
def test_wrong_exception_order(self):
tmp = self.mkdtemp()
'distutils.command.upload.urlopen',
new=mock.Mock(side_effect=exception),
):
- with self.assertRaises(raised_exception):
+ with pytest.raises(raised_exception):
cmd = upload(dist)
cmd.ensure_finalized()
cmd.run()
results = self.get_logs(ERROR)
- self.assertIn(expected, results[-1])
+ assert expected in results[-1]
self.clear_logs()
@pytest.mark.usefixtures('save_env')
class UtilTestCase(unittest.TestCase):
def setUp(self):
- super(UtilTestCase, self).setUp()
+ super().setUp()
# saving the environment
self.name = os.name
self.platform = sys.platform
else:
del os.uname
sysconfig._config_vars = copy(self._config_vars)
- super(UtilTestCase, self).tearDown()
+ super().tearDown()
def _set_uname(self, uname):
self._uname = uname
def test_get_host_platform(self):
with unittest.mock.patch('os.name', 'nt'):
with unittest.mock.patch('sys.version', '... [... (ARM64)]'):
- self.assertEqual(get_host_platform(), 'win-arm64')
+ assert get_host_platform() == 'win-arm64'
with unittest.mock.patch('sys.version', '... [... (ARM)]'):
- self.assertEqual(get_host_platform(), 'win-arm32')
+ assert get_host_platform() == 'win-arm32'
with unittest.mock.patch('sys.version_info', (3, 9, 0, 'final', 0)):
- self.assertEqual(get_host_platform(), stdlib_sysconfig.get_platform())
+ assert get_host_platform() == stdlib_sysconfig.get_platform()
def test_get_platform(self):
with unittest.mock.patch('os.name', 'nt'):
with unittest.mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x86'}):
- self.assertEqual(get_platform(), 'win32')
+ assert get_platform() == 'win32'
with unittest.mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x64'}):
- self.assertEqual(get_platform(), 'win-amd64')
+ assert get_platform() == 'win-amd64'
with unittest.mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm'}):
- self.assertEqual(get_platform(), 'win-arm32')
+ assert get_platform() == 'win-arm32'
with unittest.mock.patch.dict(
'os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm64'}
):
- self.assertEqual(get_platform(), 'win-arm64')
+ assert get_platform() == 'win-arm64'
def test_convert_path(self):
# linux/mac
os.path.join = _join
- self.assertEqual(convert_path('/home/to/my/stuff'), '/home/to/my/stuff')
+ assert convert_path('/home/to/my/stuff') == '/home/to/my/stuff'
# win
os.sep = '\\'
os.path.join = _join
- self.assertRaises(ValueError, convert_path, '/home/to/my/stuff')
- self.assertRaises(ValueError, convert_path, 'home/to/my/stuff/')
+ with pytest.raises(ValueError):
+ convert_path('/home/to/my/stuff')
+ with pytest.raises(ValueError):
+ convert_path('home/to/my/stuff/')
- self.assertEqual(convert_path('home/to/my/stuff'), 'home\\to\\my\\stuff')
- self.assertEqual(convert_path('.'), os.curdir)
+ assert convert_path('home/to/my/stuff') == 'home\\to\\my\\stuff'
+ assert convert_path('.') == os.curdir
def test_change_root(self):
# linux/mac
os.path.join = _join
- self.assertEqual(change_root('/root', '/old/its/here'), '/root/old/its/here')
- self.assertEqual(change_root('/root', 'its/here'), '/root/its/here')
+ assert change_root('/root', '/old/its/here') == '/root/old/its/here'
+ assert change_root('/root', 'its/here') == '/root/its/here'
# windows
os.name = 'nt'
os.path.join = _join
- self.assertEqual(
- change_root('c:\\root', 'c:\\old\\its\\here'), 'c:\\root\\old\\its\\here'
+ assert (
+ change_root('c:\\root', 'c:\\old\\its\\here') == 'c:\\root\\old\\its\\here'
)
- self.assertEqual(change_root('c:\\root', 'its\\here'), 'c:\\root\\its\\here')
+ assert change_root('c:\\root', 'its\\here') == 'c:\\root\\its\\here'
# BugsBunny os (it's a great os)
os.name = 'BugsBunny'
- self.assertRaises(DistutilsPlatformError, change_root, 'c:\\root', 'its\\here')
+ with pytest.raises(DistutilsPlatformError):
+ change_root('c:\\root', 'its\\here')
# XXX platforms to be covered: mac
check_environ()
- self.assertEqual(os.environ['PLAT'], get_platform())
- self.assertEqual(util._environ_checked, 1)
+ assert os.environ['PLAT'] == get_platform()
+ assert util._environ_checked == 1
@unittest.skipUnless(os.name == 'posix', 'specific to posix')
def test_check_environ_getpwuid(self):
)
with mock.patch.object(pwd, 'getpwuid', return_value=result):
check_environ()
- self.assertEqual(os.environ['HOME'], '/home/distutils')
+ assert os.environ['HOME'] == '/home/distutils'
util._environ_checked = 0
os.environ.pop('HOME', None)
# bpo-10496: Catch pwd.getpwuid() error
with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError):
check_environ()
- self.assertNotIn('HOME', os.environ)
+ assert 'HOME' not in os.environ
def test_split_quoted(self):
- self.assertEqual(
- split_quoted('""one"" "two" \'three\' \\four'),
- ['one', 'two', 'three', 'four'],
- )
+ assert split_quoted('""one"" "two" \'three\' \\four') == [
+ 'one',
+ 'two',
+ 'three',
+ 'four',
+ ]
def test_strtobool(self):
yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')
for y in yes:
- self.assertTrue(strtobool(y))
+ assert strtobool(y)
for n in no:
- self.assertFalse(strtobool(n))
+ assert not strtobool(n)
def test_rfc822_escape(self):
header = 'I am a\npoor\nlonesome\nheader\n'
wanted = ('I am a%(8s)spoor%(8s)slonesome%(8s)s' 'header%(8s)s') % {
'8s': '\n' + 8 * ' '
}
- self.assertEqual(res, wanted)
+ assert res == wanted
def test_dont_write_bytecode(self):
# makes sure byte_compile raise a DistutilsError
old_dont_write_bytecode = sys.dont_write_bytecode
sys.dont_write_bytecode = True
try:
- self.assertRaises(DistutilsByteCompileError, byte_compile, [])
+ with pytest.raises(DistutilsByteCompileError):
+ byte_compile([])
finally:
sys.dont_write_bytecode = old_dont_write_bytecode
# test obsolete function to ensure backward compat (#4931)
exc = IOError("Unable to find batch file")
msg = grok_environment_error(exc)
- self.assertEqual(msg, "error: Unable to find batch file")
+ assert msg == "error: Unable to find batch file"
def test_prerelease(self):
version = StrictVersion('1.2.3a1')
- self.assertEqual(version.version, (1, 2, 3))
- self.assertEqual(version.prerelease, ('a', 1))
- self.assertEqual(str(version), '1.2.3a1')
+ assert version.version == (1, 2, 3)
+ assert version.prerelease == ('a', 1)
+ assert str(version) == '1.2.3a1'
version = StrictVersion('1.2.0')
- self.assertEqual(str(version), '1.2')
+ assert str(version) == '1.2'
def test_cmp_strict(self):
versions = (
raise AssertionError(
("cmp(%s, %s) " "shouldn't raise ValueError") % (v1, v2)
)
- self.assertEqual(
- res, wanted, 'cmp(%s, %s) should be %s, got %s' % (v1, v2, wanted, res)
+ assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
+ v1, v2, wanted, res
)
res = StrictVersion(v1)._cmp(v2)
- self.assertEqual(
- res, wanted, 'cmp(%s, %s) should be %s, got %s' % (v1, v2, wanted, res)
+ assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
+ v1, v2, wanted, res
)
res = StrictVersion(v1)._cmp(object())
- self.assertIs(
- res,
- NotImplemented,
- 'cmp(%s, %s) should be NotImplemented, got %s' % (v1, v2, res),
- )
+ assert (
+ res is NotImplemented
+ ), 'cmp({}, {}) should be NotImplemented, got {}'.format(v1, v2, res)
def test_cmp(self):
versions = (
for v1, v2, wanted in versions:
res = LooseVersion(v1)._cmp(LooseVersion(v2))
- self.assertEqual(
- res, wanted, 'cmp(%s, %s) should be %s, got %s' % (v1, v2, wanted, res)
+ assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
+ v1, v2, wanted, res
)
res = LooseVersion(v1)._cmp(v2)
- self.assertEqual(
- res, wanted, 'cmp(%s, %s) should be %s, got %s' % (v1, v2, wanted, res)
+ assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
+ v1, v2, wanted, res
)
res = LooseVersion(v1)._cmp(object())
- self.assertIs(
- res,
- NotImplemented,
- 'cmp(%s, %s) should be NotImplemented, got %s' % (v1, v2, res),
- )
+ assert (
+ res is NotImplemented
+ ), 'cmp({}, {}) should be NotImplemented, got {}'.format(v1, v2, res)
lines, and joining lines with backslashes."""
import sys
-import io
class TextFile:
"""Open a new file named 'filename'. This overrides both the
'filename' and 'file' arguments to the constructor."""
self.filename = filename
- self.file = io.open(self.filename, 'r', errors=self.errors)
+ self.file = open(self.filename, errors=self.errors)
self.current_line = 0
def close(self):
import sys
import re
import shlex
+import itertools
from distutils import sysconfig
from distutils.dep_util import newer
return os.path.join(match.group(1), dir[1:]) if apply_root else dir
def find_library_file(self, dirs, lib, debug=0):
- """
+ r"""
Second-guess the linker with not much hard
data to go on: GCC seems to prefer the shared library, so
assume that *all* Unix C compilers do,
ignoring even GCC's "-static" option.
+
+ >>> compiler = UnixCCompiler()
+ >>> compiler._library_root = lambda dir: dir
+ >>> monkeypatch = getfixture('monkeypatch')
+ >>> monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d)
+ >>> dirs = ('/foo/bar/missing', '/foo/bar/existing')
+ >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
+ '/foo/bar/existing/libabc.dylib'
+ >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
+ '/foo/bar/existing/libabc.dylib'
+ >>> monkeypatch.setattr(os.path, 'exists',
+ ... lambda d: 'existing' in d and '.a' in d)
+ >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
+ '/foo/bar/existing/libabc.a'
+ >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
+ '/foo/bar/existing/libabc.a'
"""
lib_names = (
self.library_filename(lib, lib_type=type)
for type in 'dylib xcode_stub shared static'.split()
)
+ roots = map(self._library_root, dirs)
+
searched = (
os.path.join(root, lib_name)
- for root in map(self._library_root, dirs)
- for lib_name in lib_names
+ for root, lib_name in itertools.product(roots, lib_names)
)
found = filter(os.path.exists, searched)
print.
"""
if msg is None:
- msg = "%s%r" % (func.__name__, args)
+ msg = "{}{!r}".format(func.__name__, args)
if msg[-2:] == ',)': # correct for singleton tuple
msg = msg[0:-2] + ')'
elif val in ('n', 'no', 'f', 'false', 'off', '0'):
return 0
else:
- raise ValueError("invalid truth value %r" % (val,))
+ raise ValueError("invalid truth value {!r}".format(val))
def byte_compile( # noqa: C901
)
def __repr__(self):
- return "%s ('%s')" % (self.__class__.__name__, str(self))
+ return "{} ('{}')".format(self.__class__.__name__, str(self))
def __eq__(self, other):
c = self._cmp(other)
self.target_dir = None
def finalize_options(self):
+ log.warn(
+ "Upload_docs command is deprecated. Use Read the Docs "
+ "(https://readthedocs.org) instead.")
upload.finalize_options(self)
if self.upload_dir is None:
if self.has_sphinx():
else:
self.ensure_dirname('upload_dir')
self.target_dir = self.upload_dir
- if 'pypi.python.org' in self.repository:
- log.warn("Upload_docs command is deprecated for PyPi. Use RTD instead.")
self.announce('Using upload directory %s' % self.target_dir)
def create_zipfile(self, filename):
projects / platform / upstream / python-setuptools.git / commitdiff