diff options
Diffstat (limited to 'lib')
91 files changed, 725 insertions, 995 deletions
diff --git a/lib/spack/docs/getting_started.rst b/lib/spack/docs/getting_started.rst index d4121750db..32007332d5 100644 --- a/lib/spack/docs/getting_started.rst +++ b/lib/spack/docs/getting_started.rst @@ -1580,8 +1580,8 @@ Python 3 can be downloaded and installed from the Windows Store, and will be aut to your ``PATH`` in this case. .. note:: - Spack currently supports Python versions later than 3.2 inclusive. + """ Git """ @@ -1594,12 +1594,10 @@ When given the option of adjusting your ``PATH``, choose the ``Git from the command line and also from 3rd-party software`` option. This will automatically update your ``PATH`` variable to include the ``git`` command. -.. note:: - - Spack support on Windows is currently dependent on installing the Git for Windows project - as the project providing Git support on Windows. This is additionally the recommended method - for installing Git on Windows, a link to which can be found above. Spack requires the - utilities vendored by this project. +Spack support on Windows is currently dependent on installing the Git for Windows project +as the project providing Git support on Windows. This is additionally the recommended method +for installing Git on Windows, a link to which can be found above. Spack requires the +utilities vendored by this project. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Step 2: Install and setup Spack @@ -1609,32 +1607,20 @@ We are now ready to get the Spack environment set up on our machine. We begin by using Git to clone the Spack repo, hosted at https://github.com/spack/spack.git into a desired directory, for our purposes today, called ``spack_install``. -Presently, Windows operations are supported by Spack soley through the -features/windows-support branch on the upstream Spack repository, -located at the above url. - In order to install Spack with Windows support, run the following one liner in a Windows CMD prompt. .. code-block:: console - git clone https://github.com/spack/spack.git -b features/windows-support win_spack - -or if working from a previous clone of Spack, simply checkout the Windows support feature branch -with - -.. code-block:: console - - git checkout -b features/windows-support --track <spack_upstream>/features/windows-support + git clone https://github.com/spack/spack.git .. note:: + If you chose to install Spack into a directory on Windows that is set up to require Administrative + Privleges, Spack will require elevated privleges to run. + Administrative Privleges can be denoted either by default such as + ``C:\Program Files``, or aministrator applied administrative restrictions + on a directory that spack installs files to such as ``C:\Users`` - If you chose to install Spack into a directory on Windows that is set up to require Administrative - Privleges*, Spack will require elevated privleges to run. - - *Administrative Privleges can be denoted either by default such as - `C:\Program Files`, or aministrator applied administrative restrictions - on a directory that spack installs files to such as `C:\Users\` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Step 3: Run and configure Spack ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -1646,6 +1632,9 @@ and its prerequisites. If you receive a warning message that Python is not in yo of the Python executable to your ``PATH`` now. You can permanently add Python to your ``PATH`` variable by using the ``Edit the system environment variables`` utility in Windows Control Panel. +.. note:: + Alternatively, Powershell can be used in place of CMD + To configure Spack, first run the following command inside the Spack console: .. code-block:: console @@ -1712,6 +1701,7 @@ and not tabs, so ensure that this is the case when editing one directly. The use of Cygwin is not officially supported by Spack and is not tested. However Spack will not throw an error, so use if choosing to use Spack with Cygwin, know that no functionality is garunteed. + ^^^^^^^^^^^^^^^^^ Step 4: Use Spack ^^^^^^^^^^^^^^^^^ diff --git a/lib/spack/external/ctest_log_parser.py b/lib/spack/external/ctest_log_parser.py index d1c8db16c8..2b2746003a 100644 --- a/lib/spack/external/ctest_log_parser.py +++ b/lib/spack/external/ctest_log_parser.py @@ -71,8 +71,6 @@ from __future__ import division import re import math import multiprocessing -import sys -import threading import time from contextlib import contextmanager @@ -411,12 +409,7 @@ class CTestLogParser(object): pool = multiprocessing.Pool(jobs) try: # this is a workaround for a Python bug in Pool with ctrl-C - if sys.version_info >= (3, 2): - max_timeout = threading.TIMEOUT_MAX - else: - max_timeout = 9999999 - results = pool.map_async(_parse_unpack, args, 1).get(max_timeout) - + results = pool.map_async(_parse_unpack, args, 1).get(9999999) errors, warnings, timings = zip(*results) finally: pool.terminate() diff --git a/lib/spack/external/macholib/util.py b/lib/spack/external/macholib/util.py index 4eb4bd60e7..d5ab33544a 100644 --- a/lib/spack/external/macholib/util.py +++ b/lib/spack/external/macholib/util.py @@ -6,8 +6,6 @@ import sys from macholib import mach_o -from llnl.util.symlink import symlink - MAGIC = [ struct.pack("!L", getattr(mach_o, "MH_" + _)) for _ in ["MAGIC", "CIGAM", "MAGIC_64", "CIGAM_64"] @@ -142,7 +140,7 @@ def mergetree(src, dst, condition=None, copyfn=mergecopy, srcbase=None): try: if os.path.islink(srcname): realsrc = os.readlink(srcname) - symlink(realsrc, dstname) + os.symlink(realsrc, dstname) elif os.path.isdir(srcname): mergetree( srcname, diff --git a/lib/spack/external/pytest-fallback/py/_path/local.py b/lib/spack/external/pytest-fallback/py/_path/local.py index 72ffb9f6cb..d2f16b993e 100644 --- a/lib/spack/external/pytest-fallback/py/_path/local.py +++ b/lib/spack/external/pytest-fallback/py/_path/local.py @@ -12,8 +12,6 @@ from stat import S_ISLNK, S_ISDIR, S_ISREG from os.path import abspath, normpath, isabs, exists, isdir, isfile, islink, dirname -from llnl.util.symlink import symlink - if sys.version_info > (3,0): def map_as_list(func, iter): return list(map(func, iter)) @@ -81,7 +79,7 @@ class PosixPath(common.PathBase): def mksymlinkto(self, value, absolute=1): """ create a symbolic link with the given value (pointing to another name). """ if absolute: - py.error.checked_call(symlink, str(value), self.strpath) + py.error.checked_call(os.symlink, str(value), self.strpath) else: base = self.common(value) # with posix local paths '/' is always a common base @@ -89,7 +87,7 @@ class PosixPath(common.PathBase): reldest = self.relto(base) n = reldest.count(self.sep) target = self.sep.join(('..', )*n + (relsource, )) - py.error.checked_call(symlink, target, self.strpath) + py.error.checked_call(os.symlink, target, self.strpath) def getuserid(user): import pwd @@ -894,7 +892,7 @@ class LocalPath(FSBase): except OSError: pass try: - symlink(src, dest) + os.symlink(src, dest) except (OSError, AttributeError, NotImplementedError): pass diff --git a/lib/spack/llnl/util/filesystem.py b/lib/spack/llnl/util/filesystem.py index 9f46b275b2..22ca97c347 100644 --- a/lib/spack/llnl/util/filesystem.py +++ b/lib/spack/llnl/util/filesystem.py @@ -1094,12 +1094,23 @@ def remove_linked_tree(path): Parameters: path (str): Directory to be removed """ + # On windows, cleaning a Git stage can be an issue + # as git leaves readonly files that Python handles + # poorly on Windows. Remove readonly status and try again + def onerror(func, path, exe_info): + os.chmod(path, stat.S_IWUSR) + try: + func(path) + except Exception as e: + tty.warn(e) + pass + if os.path.exists(path): if os.path.islink(path): - shutil.rmtree(os.path.realpath(path), True) + shutil.rmtree(os.path.realpath(path), onerror=onerror) os.unlink(path) else: - shutil.rmtree(path, True) + shutil.rmtree(path, onerror=onerror) @contextmanager @@ -1237,9 +1248,6 @@ def find(root, files, recursive=True): return _find_non_recursive(root, files) -# here and in _find_non_recursive below we only take the first -# index to check for system path safety as glob handles this -# w.r.t. search_files @system_path_filter def _find_recursive(root, search_files): diff --git a/lib/spack/llnl/util/lock.py b/lib/spack/llnl/util/lock.py index 37989bac35..1ff7ceec64 100644 --- a/lib/spack/llnl/util/lock.py +++ b/lib/spack/llnl/util/lock.py @@ -191,6 +191,7 @@ class LockType(object): return op == LockType.READ \ or op == LockType.WRITE + class Lock(object): """This is an implementation of a filesystem lock using Python's lockf. @@ -617,6 +618,12 @@ class Lock(object): else: return False + def cleanup(self): + if self._reads == 0 and self._writes == 0: + os.unlink(self.path) + else: + raise LockError("Attempting to cleanup active lock.") + def _get_counts_desc(self): return '(reads {0}, writes {1})'.format(self._reads, self._writes) \ if tty.is_verbose() else '' diff --git a/lib/spack/llnl/util/tty/__init__.py b/lib/spack/llnl/util/tty/__init__.py index ae7634afea..de49f3f77f 100644 --- a/lib/spack/llnl/util/tty/__init__.py +++ b/lib/spack/llnl/util/tty/__init__.py @@ -395,7 +395,7 @@ def terminal_size(): return int(rc[0]), int(rc[1]) else: if sys.version_info[0] < 3: - raise RuntimeError("""Terminal size not obtainable on Windows with a - Python version older than 3""") + raise RuntimeError("Terminal size not obtainable on Windows with a\ +Python version older than 3") rc = (os.environ.get('LINES', 25), os.environ.get('COLUMNS', 80)) return int(rc[0]), int(rc[1]) diff --git a/lib/spack/llnl/util/tty/log.py b/lib/spack/llnl/util/tty/log.py index 0df3cf7829..544a9a6c48 100644 --- a/lib/spack/llnl/util/tty/log.py +++ b/lib/spack/llnl/util/tty/log.py @@ -418,6 +418,7 @@ def log_output(*args, **kwargs): with log_output('logfile.txt', echo=True): # do things ... output will be logged and printed out + The following is available on Unix only. No-op on Windows. And, if you just want to echo *some* stuff from the parent, use ``force_echo``:: @@ -427,20 +428,11 @@ def log_output(*args, **kwargs): with logger.force_echo(): # things here will be echoed *and* logged - Under the hood, we spawn a daemon and set up a pipe between this - process and the daemon. The daemon writes our output to both the - file and to stdout (if echoing). The parent process can communicate - with the daemon to tell it when and when not to echo; this is what - force_echo does. You can also enable/disable echoing by typing 'v'. - - We try to use OS-level file descriptors to do the redirection, but if - stdout or stderr has been set to some Python-level file object, we - use Python-level redirection instead. This allows the redirection to - work within test frameworks like nose and pytest. + See individual log classes for more information. This method is actually a factory serving a per platform - (nix vs windows) log_output class + (unix vs windows) log_output class """ if sys.platform == 'win32': return winlog(*args, **kwargs) @@ -449,29 +441,7 @@ def log_output(*args, **kwargs): class nixlog(object): - """Context manager that logs its output to a file. - - In the simplest case, the usage looks like this:: - - with log_output('logfile.txt'): - # do things ... output will be logged - - Any output from the with block will be redirected to ``logfile.txt``. - If you also want the output to be echoed to ``stdout``, use the - ``echo`` parameter:: - - with log_output('logfile.txt', echo=True): - # do things ... output will be logged and printed out - - And, if you just want to echo *some* stuff from the parent, use - ``force_echo``:: - - with log_output('logfile.txt', echo=False) as logger: - # do things ... output will be logged - - with logger.force_echo(): - # things here will be echoed *and* logged - + """ Under the hood, we spawn a daemon and set up a pipe between this process and the daemon. The daemon writes our output to both the file and to stdout (if echoing). The parent process can communicate @@ -748,7 +718,6 @@ class StreamWrapper: self.libc = libc self.c_stream = c_stdout else: - # The original fd stdout points to. Usually 1 on POSIX systems for stdout. self.libc = ctypes.CDLL(None) self.c_stream = ctypes.c_void_p.in_dll(self.libc, self.sys_attr) self.sys_stream = getattr(sys, self.sys_attr) @@ -793,6 +762,12 @@ class StreamWrapper: class winlog(object): + """ + Similar to nixlog, with underlying + functionality ported to support Windows. + + Does not support the use of 'v' toggling as nixlog does. + """ def __init__(self, file_like=None, echo=False, debug=0, buffer=False, env=None, filter_fn=None): self.env = env diff --git a/lib/spack/spack/build_systems/cmake.py b/lib/spack/spack/build_systems/cmake.py index 9fd2267d51..6e6b5e20b0 100644 --- a/lib/spack/spack/build_systems/cmake.py +++ b/lib/spack/spack/build_systems/cmake.py @@ -19,6 +19,7 @@ from llnl.util.filesystem import working_dir import spack.build_environment from spack.directives import conflicts, depends_on, variant from spack.package import InstallError, PackageBase, run_after +from spack.util.path import convert_to_posix_path # Regex to extract the primary generator from the CMake generator # string. @@ -173,7 +174,7 @@ class CMakePackage(PackageBase): define = CMakePackage.define args = [ '-G', generator, - define('CMAKE_INSTALL_PREFIX', pkg.prefix.replace('\\', '/')), + define('CMAKE_INSTALL_PREFIX', convert_to_posix_path(pkg.prefix)), define('CMAKE_BUILD_TYPE', build_type), ] diff --git a/lib/spack/spack/cmd/create.py b/lib/spack/spack/cmd/create.py index 1a496a9842..1281c6d9ef 100644 --- a/lib/spack/spack/cmd/create.py +++ b/lib/spack/spack/cmd/create.py @@ -758,7 +758,15 @@ def get_versions(args, name): # Default guesser guesser = BuildSystemGuesser() - if args.url is not None and args.template != 'bundle': + valid_url = True + try: + spack.util.url.require_url_format(args.url) + if args.url.startswith('file://'): + valid_url = False # No point in spidering these + except AssertionError: + valid_url = False + + if args.url is not None and args.template != 'bundle' and valid_url: # Find available versions try: url_dict = spack.util.web.find_versions_of_archive(args.url) diff --git a/lib/spack/spack/cmd/make_installer.py b/lib/spack/spack/cmd/make_installer.py index c1bced479f..761401ea37 100644 --- a/lib/spack/spack/cmd/make_installer.py +++ b/lib/spack/spack/cmd/make_installer.py @@ -9,6 +9,7 @@ import sys import spack.paths import spack.util.executable from spack.spec import Spec +from spack.util.path import convert_to_posix_path description = "generate Windows installer" section = "admin" @@ -77,13 +78,13 @@ def make_installer(parser, args): else: if not os.path.isabs(spack_source): spack_source = posixpath.abspath(spack_source) - spack_source = spack_source.replace('\\', '/') + spack_source = convert_to_posix_path(spack_source) spack_version = args.spack_version here = os.path.dirname(os.path.abspath(__file__)) source_dir = os.path.join(here, "installer") - posix_root = spack.paths.spack_root.replace('\\', '/') + posix_root = convert_to_posix_path(spack.paths.spack_root) spack_license = posixpath.join(posix_root, "LICENSE-APACHE") rtf_spack_license = txt_to_rtf(spack_license) spack_license = posixpath.join(source_dir, "LICENSE.rtf") diff --git a/lib/spack/spack/compilers/msvc.py b/lib/spack/spack/compilers/msvc.py index fe5014128e..a3c5a7c752 100644 --- a/lib/spack/spack/compilers/msvc.py +++ b/lib/spack/spack/compilers/msvc.py @@ -83,13 +83,13 @@ class Msvc(Compiler): self.setvarsfile = os.path.join( os.getenv("ONEAPI_ROOT"), "setvars.bat") else: - # The long relative path below points six directories up - # to the root of the MSVC tree associated with this (self) - # vesion of MSVC, so that we can then find the relevant - # VCVARS file. Note: This is done in the opposite order - # that this procedure typically goes on Windows - # However it is done this way here with great intent to conform - # with how Spack discovers compilers. + # To use the MSVC compilers, VCVARS must be invoked + # VCVARS is located at a fixed location, referencable + # idiomatically by the following relative path from the + # compiler. + # Spack first finds the compilers via VSWHERE + # and stores their path, but their respective VCVARS + # file must be invoked before useage. self.setvarsfile = os.path.abspath( os.path.join(self.cc, '../../../../../../..')) self.setvarsfile = os.path.join( diff --git a/lib/spack/spack/detection/path.py b/lib/spack/spack/detection/path.py index 32e5f57af7..ef0bffad67 100644 --- a/lib/spack/spack/detection/path.py +++ b/lib/spack/spack/detection/path.py @@ -42,12 +42,12 @@ def executables_in_path(path_hints=None): path_hints (list): list of paths to be searched. If None the list will be constructed based on the PATH environment variable. """ - # build_environment.py::1013: If we're on a Windows box, run vswhere, + # If we're on a Windows box, run vswhere, # steal the installationPath using windows_os.py logic, # construct paths to CMake and Ninja, add to PATH path_hints = path_hints or spack.util.environment.get_path('PATH') if sys.platform == 'win32': - msvc_paths = winOs.WindowsOs.vs_install_paths + msvc_paths = list(winOs.WindowsOs.vs_install_paths) msvc_cmake_paths = [ os.path.join(path, "Common7", "IDE", "CommonExtensions", "Microsoft", "CMake", "CMake", "bin") @@ -91,8 +91,9 @@ def by_executable(packages_to_check, path_hints=None): path_hints = [] if path_hints is None else path_hints exe_pattern_to_pkgs = collections.defaultdict(list) for pkg in packages_to_check: - for exe in pkg.platform_executables: - exe_pattern_to_pkgs[exe].append(pkg) + if hasattr(pkg, 'executables'): + for exe in pkg.platform_executables: + exe_pattern_to_pkgs[exe].append(pkg) # Add Windows specific, package related paths to the search paths path_hints.extend(compute_windows_program_path_for_package(pkg)) diff --git a/lib/spack/spack/environment/environment.py b/lib/spack/spack/environment/environment.py index 9d6c5ba8c8..a3e35a234a 100644 --- a/lib/spack/spack/environment/environment.py +++ b/lib/spack/spack/environment/environment.py @@ -16,8 +16,9 @@ import six import llnl.util.filesystem as fs import llnl.util.tty as tty +from llnl.util.filesystem import rename from llnl.util.lang import dedupe -from llnl.util.symlink import islink, symlink +from llnl.util.symlink import symlink import spack.bootstrap import spack.compilers @@ -530,14 +531,14 @@ class ViewDescriptor(object): tmp_symlink_name = os.path.join(root_dirname, '._view_link') if os.path.exists(tmp_symlink_name): os.unlink(tmp_symlink_name) - os.symlink(new_root, tmp_symlink_name) + symlink(new_root, tmp_symlink_name) # mv symlink atomically over root symlink to old_root if os.path.exists(self.root) and not os.path.islink(self.root): msg = "Cannot create view: " msg += "file already exists and is not a link: %s" % self.root raise SpackEnvironmentViewError(msg) - os.rename(tmp_symlink_name, self.root) + rename(tmp_symlink_name, self.root) # remove old_root if old_root and os.path.exists(old_root): diff --git a/lib/spack/spack/fetch_strategy.py b/lib/spack/spack/fetch_strategy.py index 7abcea7383..94b5fab042 100644 --- a/lib/spack/spack/fetch_strategy.py +++ b/lib/spack/spack/fetch_strategy.py @@ -634,7 +634,6 @@ class CacheURLFetchStrategy(URLFetchStrategy): @_needs_stage def fetch(self): reg_str = r'^file://' - reg_str += '/' if is_windows else '' path = re.sub(reg_str, '', self.url) # check whether the cache file exists. diff --git a/lib/spack/spack/hooks/sbang.py b/lib/spack/spack/hooks/sbang.py index 2793906ebd..bef30d2b76 100644 --- a/lib/spack/spack/hooks/sbang.py +++ b/lib/spack/spack/hooks/sbang.py @@ -30,7 +30,7 @@ else: #: Groupdb does not exist on Windows, prevent imports #: on supported systems -is_windows = str(spack.platforms.host()) == 'windows' +is_windows = sys.platform == 'win32' if not is_windows: import grp diff --git a/lib/spack/spack/operating_systems/windows_os.py b/lib/spack/spack/operating_systems/windows_os.py index 879a2b77c7..61525df887 100755 --- a/lib/spack/spack/operating_systems/windows_os.py +++ b/lib/spack/spack/operating_systems/windows_os.py @@ -65,9 +65,10 @@ class WindowsOs(OperatingSystem): compiler_search_paths = comp_search_paths def __init__(self): - if Version(platform.release()) < Version('10'): + plat_ver = platform.release() + if Version(plat_ver) < Version('10'): raise SpackError("Spack is not supported on Windows versions older than 10") - super(WindowsOs, self).__init__('Windows10', '10') + super(WindowsOs, self).__init__('windows{}'.format(plat_ver), plat_ver) def __str__(self): return self.name diff --git a/lib/spack/spack/package.py b/lib/spack/spack/package.py index d91c5109ae..5888416b10 100644 --- a/lib/spack/spack/package.py +++ b/lib/spack/spack/package.py @@ -59,6 +59,7 @@ from spack.installer import InstallError, PackageInstaller from spack.stage import ResourceStage, Stage, StageComposite, stage_prefix from spack.util.executable import ProcessError, which from spack.util.package_hash import package_hash +from spack.util.path import win_exe_ext from spack.util.prefix import Prefix from spack.version import Version @@ -176,9 +177,29 @@ class DetectablePackageMeta(object): for the detection function. """ def __init__(cls, name, bases, attr_dict): - # If a package has the executables attribute then it's - # assumed to be detectable + # On windows, extend the list of regular expressions to look for + # filenames ending with ".exe" + # (in some cases these regular expressions include "$" to avoid + # pulling in filenames with unexpected suffixes, but this allows + # for example detecting "foo.exe" when the package writer specified + # that "foo" was a possible executable. if hasattr(cls, 'executables'): + @property + def platform_executables(self): + def to_windows_exe(exe): + if exe.endswith('$'): + exe = exe.replace('$', '%s$' % win_exe_ext()) + else: + exe += win_exe_ext() + return exe + plat_exe = [] + if hasattr(self, 'executables'): + for exe in self.executables: + if sys.platform == 'win32': + exe = to_windows_exe(exe) + plat_exe.append(exe) + return plat_exe + @classmethod def determine_spec_details(cls, prefix, exes_in_prefix): """Allow ``spack external find ...`` to locate installations. @@ -264,6 +285,13 @@ class DetectablePackageMeta(object): if default and not hasattr(cls, 'determine_variants'): cls.determine_variants = determine_variants + # This function should not be overridden by subclasses, + # as it is not designed for bespoke pkg detection but rather + # on a per-platform basis + if hasattr(cls, 'platform_executables'): + raise PackageError("Packages should not override platform_executables") + cls.platform_executables = platform_executables + super(DetectablePackageMeta, cls).__init__(name, bases, attr_dict) @@ -898,16 +926,6 @@ class PackageBase(six.with_metaclass(PackageMeta, PackageViewMixin, object)): " does not have a concrete version.") return self.spec.versions[0] - @property - def platform_executables(self): - plat_exe = [] - if hasattr(self, 'executables'): - for exe in self.executables: - if sys.platform == 'win32': - exe = exe.replace('$', r'\.exe$') - plat_exe.append(exe) - return plat_exe - @memoized def version_urls(self): """OrderedDict of explicitly defined URLs for versions of this package. diff --git a/lib/spack/spack/parse.py b/lib/spack/spack/parse.py index 2d4dce3a75..603848a3a0 100644 --- a/lib/spack/spack/parse.py +++ b/lib/spack/spack/parse.py @@ -13,6 +13,7 @@ from six import string_types import spack.error import spack.util.path as sp + class Token(object): """Represents tokens; generated from input by lexer and fed to parse().""" diff --git a/lib/spack/spack/paths.py b/lib/spack/spack/paths.py index 4d8747d741..b423e9e6c5 100644 --- a/lib/spack/spack/paths.py +++ b/lib/spack/spack/paths.py @@ -81,7 +81,8 @@ gpg_path = os.path.join(opt_path, "spack", "gpg") # setting `SPACK_USER_CACHE_PATH`. Otherwise it defaults to ~/.spack. # def _get_user_cache_path(): - return os.path.expanduser(os.getenv('SPACK_USER_CACHE_PATH') or "~/.spack") + return os.path.expanduser(os.getenv('SPACK_USER_CACHE_PATH') + or "~%s.spack" % os.sep) user_cache_path = _get_user_cache_path() @@ -116,12 +117,14 @@ default_misc_cache_path = os.path.join(user_cache_path, 'cache') # User configuration and caches in $HOME/.spack def _get_user_config_path(): - return os.path.expanduser(os.getenv('SPACK_USER_CONFIG_PATH') or "~/.spack") + return os.path.expanduser(os.getenv('SPACK_USER_CONFIG_PATH') or + "~%s.spack" % os.sep) # Configuration in /etc/spack on the system def _get_system_config_path(): - return os.path.expanduser(os.getenv('SPACK_SYSTEM_CONFIG_PATH') or "/etc/spack") + return os.path.expanduser(os.getenv('SPACK_SYSTEM_CONFIG_PATH') or + os.sep + os.path.join('etc', 'spack')) #: User configuration location diff --git a/lib/spack/spack/platforms/windows.py b/lib/spack/spack/platforms/windows.py index 552e520193..9626b29cc8 100755 --- a/lib/spack/spack/platforms/windows.py +++ b/lib/spack/spack/platforms/windows.py @@ -16,8 +16,6 @@ from ._platform import Platform class Windows(Platform): priority = 101 - # binary_formats = ['macho'] - def __init__(self): super(Windows, self).__init__('windows') diff --git a/lib/spack/spack/repo.py b/lib/spack/spack/repo.py index e1403bd44f..904c22d9ba 100644 --- a/lib/spack/spack/repo.py +++ b/lib/spack/spack/repo.py @@ -330,7 +330,8 @@ class RepoIndex(object): self.checker = package_checker self.packages_path = self.checker.packages_path if sys.platform == 'win32': - self.packages_path = self.packages_path.replace("\\", "/") + self.packages_path = \ + spack.util.path.convert_to_posix_path(self.packages_path) self.namespace = namespace self.indexers = {} diff --git a/lib/spack/spack/spec.py b/lib/spack/spack/spec.py index 7feebdd4e2..b4c778ee76 100644 --- a/lib/spack/spack/spec.py +++ b/lib/spack/spack/spec.py @@ -111,6 +111,7 @@ import spack.util.crypto import spack.util.executable import spack.util.hash import spack.util.module_cmd as md +import spack.util.path as pth import spack.util.prefix import spack.util.spack_json as sjson import spack.util.spack_yaml as syaml @@ -1724,7 +1725,7 @@ class Spec(object): @prefix.setter def prefix(self, value): - self._prefix = spack.util.prefix.Prefix(value) + self._prefix = spack.util.prefix.Prefix(pth.convert_to_platform_path(value)) def _spec_hash(self, hash): """Utility method for computing different types of Spec hashes. @@ -4876,6 +4877,10 @@ class SpecLexer(spack.parse.Lexer): """Parses tokens that make up spack specs.""" def __init__(self): + # Spec strings require posix-style paths on Windows + # because the result is later passed to shlex + filename_reg = r'[/\w.-]*/[/\w/-]+\.(yaml|json)[^\b]*' if not is_windows\ + else r'([A-Za-z]:)*?[/\w.-]*/[/\w/-]+\.(yaml|json)[^\b]*' super(SpecLexer, self).__init__([ (r'\^', lambda scanner, val: self.token(DEP, val)), (r'\@', lambda scanner, val: self.token(AT, val)), @@ -4889,10 +4894,7 @@ class SpecLexer(spack.parse.Lexer): # Filenames match before identifiers, so no initial filename # component is parsed as a spec (e.g., in subdir/spec.yaml/json) - # posixpath on Windows here because this string will be fed through - # shlex - (r'[/\w.-]*/[/\w/-]+\.(yaml|json)[^\b]*' if not is_windows\ - else r'([A-Za-z]:)*?[/\w.-]*/[/\w/-]+\.(yaml|json)[^\b]*', + (filename_reg, lambda scanner, v: self.token(FILE, v)), # Hash match after filename. No valid filename can be a hash diff --git a/lib/spack/spack/test/architecture.py b/lib/spack/spack/test/architecture.py index a9b168f863..18a8dbe1b6 100644 --- a/lib/spack/spack/test/architecture.py +++ b/lib/spack/spack/test/architecture.py @@ -4,6 +4,7 @@ # SPDX-License-Identifier: (Apache-2.0 OR MIT) import os import platform +import sys import pytest @@ -58,8 +59,8 @@ def test_platform(current_host_platform): assert str(detected_platform) == str(current_host_platform) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Test unsupported on Windows") +@pytest.mark.skipif(sys.platform == 'win32', + reason="Not supported on Windows (yet)") def test_user_input_combination(config, target_str, os_str): """Test for all the valid user input combinations that both the target and the operating system match. diff --git a/lib/spack/spack/test/build_distribution.py b/lib/spack/spack/test/build_distribution.py index c2008ffa63..c5132a9558 100644 --- a/lib/spack/spack/test/build_distribution.py +++ b/lib/spack/spack/test/build_distribution.py @@ -18,6 +18,15 @@ pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="does not run on windows") +def _validate_url(url): + return + + +@pytest.fixture(autouse=True) +def url_check(monkeypatch): + monkeypatch.setattr(spack.util.url, 'require_url_format', _validate_url) + + def test_build_tarball_overwrite( install_mockery, mock_fetch, monkeypatch, tmpdir): diff --git a/lib/spack/spack/test/build_environment.py b/lib/spack/spack/test/build_environment.py index 50241e6c9e..a816ac4ba9 100644 --- a/lib/spack/spack/test/build_environment.py +++ b/lib/spack/spack/test/build_environment.py @@ -24,6 +24,18 @@ from spack.build_environment import ( from spack.paths import build_env_path from spack.util.environment import EnvironmentModifications from spack.util.executable import Executable +from spack.util.path import Path, convert_to_platform_path + + +def os_pathsep_join(path, *pths): + out_pth = path + for pth in pths: + out_pth = os.pathsep.join([out_pth, pth]) + return out_pth + + +def prep_and_join(path, *pths): + return os.path.sep + os.path.join(path, *pths) @pytest.fixture @@ -84,7 +96,7 @@ def ensure_env_variables(config, mock_packages, monkeypatch, working_env): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Static to Shared not supported on Win (yet)") def test_static_to_shared_library(build_environment): os.environ['SPACK_TEST_COMMAND'] = 'dump-args' @@ -139,8 +151,6 @@ def test_cc_not_changed_by_modules(monkeypatch, working_env): assert os.environ['ANOTHER_VAR'] == 'THIS_IS_SET' -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('initial,modifications,expected', [ # Set and unset variables ({'SOME_VAR_STR': '', 'SOME_VAR_NUM': '0'}, @@ -153,25 +163,32 @@ def test_cc_not_changed_by_modules(monkeypatch, working_env): {'set': {'SOME_VAR_STR': 'SOME_STR'}}, {'SOME_VAR_STR': 'SOME_STR'}), # Append and prepend to the same variable - ({'EMPTY_PATH_LIST': '/path/middle'}, - {'prepend_path': {'EMPTY_PATH_LIST': '/path/first'}, - 'append_path': {'EMPTY_PATH_LIST': '/path/last'}}, - {'EMPTY_PATH_LIST': '/path/first:/path/middle:/path/last'}), + ({'EMPTY_PATH_LIST': prep_and_join('path', 'middle')}, + {'prepend_path': {'EMPTY_PATH_LIST': prep_and_join('path', 'first')}, + 'append_path': {'EMPTY_PATH_LIST': prep_and_join('path', 'last')}}, + {'EMPTY_PATH_LIST': os_pathsep_join(prep_and_join('path', 'first'), + prep_and_join('path', 'middle'), + prep_and_join('path', 'last'))}), # Append and prepend from empty variables ({'EMPTY_PATH_LIST': '', 'SOME_VAR_STR': ''}, - {'prepend_path': {'EMPTY_PATH_LIST': '/path/first'}, - 'append_path': {'SOME_VAR_STR': '/path/last'}}, - {'EMPTY_PATH_LIST': '/path/first', 'SOME_VAR_STR': '/path/last'}), + {'prepend_path': {'EMPTY_PATH_LIST': prep_and_join('path', 'first')}, + 'append_path': {'SOME_VAR_STR': prep_and_join('path', 'last')}}, + {'EMPTY_PATH_LIST': prep_and_join('path', 'first'), + 'SOME_VAR_STR': prep_and_join('path', 'last')}), ({}, # Same as before but on variables that were not defined - {'prepend_path': {'EMPTY_PATH_LIST': '/path/first'}, - 'append_path': {'SOME_VAR_STR': '/path/last'}}, - {'EMPTY_PATH_LIST': '/path/first', 'SOME_VAR_STR': '/path/last'}), + {'prepend_path': {'EMPTY_PATH_LIST': prep_and_join('path', 'first')}, + 'append_path': {'SOME_VAR_STR': prep_and_join('path', 'last')}}, + {'EMPTY_PATH_LIST': prep_and_join('path', 'first'), + 'SOME_VAR_STR': prep_and_join('path', 'last')}), # Remove a path from a list - ({'EMPTY_PATH_LIST': '/path/first:/path/middle:/path/last'}, - {'remove_path': {'EMPTY_PATH_LIST': '/path/middle'}}, - {'EMPTY_PATH_LIST': '/path/first:/path/last'}), - ({'EMPTY_PATH_LIST': '/only/path'}, - {'remove_path': {'EMPTY_PATH_LIST': '/only/path'}}, + ({'EMPTY_PATH_LIST': os_pathsep_join(prep_and_join('path', 'first'), + prep_and_join('path', 'middle'), + prep_and_join('path', 'last'))}, + {'remove_path': {'EMPTY_PATH_LIST': prep_and_join('path', 'middle')}}, + {'EMPTY_PATH_LIST': os_pathsep_join(prep_and_join('path', 'first'), + prep_and_join('path', 'last'))}), + ({'EMPTY_PATH_LIST': prep_and_join('only', 'path')}, + {'remove_path': {'EMPTY_PATH_LIST': prep_and_join('only', 'path')}}, {'EMPTY_PATH_LIST': ''}), ]) def test_compiler_config_modifications( @@ -180,16 +197,22 @@ def test_compiler_config_modifications( # Set the environment as per prerequisites ensure_env_variables(initial) + def platform_pathsep(pathlist): + if Path.platform_path == Path.windows: + pathlist = pathlist.replace(':', ';') + + return convert_to_platform_path(pathlist) + # Monkeypatch a pkg.compiler.environment with the required modifications pkg = spack.spec.Spec('cmake').concretized().package monkeypatch.setattr(pkg.compiler, 'environment', modifications) - # Trigger the modifications spack.build_environment.setup_package(pkg, False) # Check they were applied for name, value in expected.items(): if value is not None: + value = platform_pathsep(value) assert os.environ[name] == value continue assert name not in os.environ diff --git a/lib/spack/spack/test/buildrequest.py b/lib/spack/spack/test/buildrequest.py index 86c4a37d0f..a4ae76086a 100644 --- a/lib/spack/spack/test/buildrequest.py +++ b/lib/spack/spack/test/buildrequest.py @@ -11,9 +11,10 @@ import spack.installer as inst import spack.repo import spack.spec -# Functionality supported on windows however tests are currently failing -# due to compatibility issues, or due to dependent components currently -# being unsupported on Windows +# Spack functionality tested here should work on Windows, +# however, tests are currently failing because support +# for Spack on Windows has not been extended to this +# module yet. pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="does not run on windows") diff --git a/lib/spack/spack/test/cache_fetch.py b/lib/spack/spack/test/cache_fetch.py index 44a5275868..828dd81791 100644 --- a/lib/spack/spack/test/cache_fetch.py +++ b/lib/spack/spack/test/cache_fetch.py @@ -4,6 +4,7 @@ # SPDX-License-Identifier: (Apache-2.0 OR MIT) import os +import sys import pytest @@ -13,13 +14,17 @@ import spack.config from spack.fetch_strategy import CacheURLFetchStrategy, NoCacheError from spack.stage import Stage +is_windows = sys.platform == 'win32' + @pytest.mark.parametrize('_fetch_method', ['curl', 'urllib']) def test_fetch_missing_cache(tmpdir, _fetch_method): """Ensure raise a missing cache file.""" testpath = str(tmpdir) with spack.config.override('config:url_fetch_method', _fetch_method): - fetcher = CacheURLFetchStrategy(url='file:///not-a-real-cache-file') + abs_pref = '' if is_windows else '/' + url = 'file://' + abs_pref + 'not-a-real-cache-file' + fetcher = CacheURLFetchStrategy(url=url) with Stage(fetcher, path=testpath): with pytest.raises(NoCacheError, match=r'No cache'): fetcher.fetch() @@ -31,7 +36,11 @@ def test_fetch(tmpdir, _fetch_method): testpath = str(tmpdir) cache = os.path.join(testpath, 'cache.tar.gz') touch(cache) - url = 'file:///{0}'.format(cache) + if is_windows: + url_stub = '{0}' + else: + url_stub = '/{0}' + url = 'file://' + url_stub.format(cache) with spack.config.override('config:url_fetch_method', _fetch_method): fetcher = CacheURLFetchStrategy(url=url) with Stage(fetcher, path=testpath) as stage: diff --git a/lib/spack/spack/test/cmd/common/arguments.py b/lib/spack/spack/test/cmd/common/arguments.py index 763c6880c0..5f1299a94a 100644 --- a/lib/spack/spack/test/cmd/common/arguments.py +++ b/lib/spack/spack/test/cmd/common/arguments.py @@ -4,7 +4,6 @@ # SPDX-License-Identifier: (Apache-2.0 OR MIT) import argparse -import sys import pytest @@ -63,8 +62,6 @@ def test_parse_spec_flags_with_spaces( assert all(x in s.variants for x in expected_variants) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('config') def test_match_spec_env(mock_packages, mutable_mock_env_path): """ @@ -87,8 +84,6 @@ def test_match_spec_env(mock_packages, mutable_mock_env_path): assert env_spec.concrete -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('config') def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path): e = ev.create('test') @@ -102,8 +97,6 @@ def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path): assert 'matches multiple specs' in exc_info.value.message -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('config') def test_root_and_dep_match_returns_root(mock_packages, mutable_mock_env_path): e = ev.create('test') diff --git a/lib/spack/spack/test/cmd/compiler.py b/lib/spack/spack/test/cmd/compiler.py index 26dcb7ff59..f799d96b0f 100644 --- a/lib/spack/spack/test/cmd/compiler.py +++ b/lib/spack/spack/test/cmd/compiler.py @@ -105,7 +105,8 @@ def test_compiler_remove(mutable_config, mock_packages): assert spack.spec.CompilerSpec("gcc@4.5.0") not in compilers -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") +@pytest.mark.skipif(sys.platform == 'win32', reason="Cannot execute bash \ + script on Windows") def test_compiler_add( mutable_config, mock_packages, mock_compiler_dir, mock_compiler_version ): diff --git a/lib/spack/spack/test/cmd/concretize.py b/lib/spack/spack/test/cmd/concretize.py index c630ebeb68..d357ccc9dc 100644 --- a/lib/spack/spack/test/cmd/concretize.py +++ b/lib/spack/spack/test/cmd/concretize.py @@ -3,7 +3,6 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) -import sys import pytest @@ -19,7 +18,6 @@ add = SpackCommand('add') concretize = SpackCommand('concretize') -@pytest.mark.skipif(sys.platform == "win32", reason="Test unsupported on Windows") @pytest.mark.parametrize('concretization', ['separately', 'together']) def test_concretize_all_test_dependencies(concretization): """Check all test dependencies are concretized.""" @@ -32,7 +30,6 @@ def test_concretize_all_test_dependencies(concretization): assert e.matching_spec('test-dependency') -@pytest.mark.skipif(sys.platform == "win32", reason="Test unsupported on Windows") @pytest.mark.parametrize('concretization', ['separately', 'together']) def test_concretize_root_test_dependencies_not_recursive(concretization): """Check that test dependencies are not concretized recursively.""" @@ -45,7 +42,6 @@ def test_concretize_root_test_dependencies_not_recursive(concretization): assert e.matching_spec('test-dependency') is None -@pytest.mark.skipif(sys.platform == "win32", reason="Test unsupported on Windows") @pytest.mark.parametrize('concretization', ['separately', 'together']) def test_concretize_root_test_dependencies_are_concretized(concretization): """Check that root test dependencies are concretized.""" diff --git a/lib/spack/spack/test/cmd/config.py b/lib/spack/spack/test/cmd/config.py index a76ec07ca5..e8dc80c6da 100644 --- a/lib/spack/spack/test/cmd/config.py +++ b/lib/spack/spack/test/cmd/config.py @@ -4,7 +4,6 @@ # SPDX-License-Identifier: (Apache-2.0 OR MIT) import functools import os -import sys import pytest @@ -426,11 +425,8 @@ def test_remove_list(mutable_empty_config): """ - -@pytest.mark.skipif(sys.platform == 'win32', - reason="Lockfiles not support on Windows (yet)") def test_config_add_to_env(mutable_empty_config, mutable_mock_env_path): - ev.create('test') + env('create', 'test') with ev.read('test'): config('add', 'config:dirty:true') output = config('get') diff --git a/lib/spack/spack/test/cmd/env.py b/lib/spack/spack/test/cmd/env.py index ae47aada02..868eb8ec45 100644 --- a/lib/spack/spack/test/cmd/env.py +++ b/lib/spack/spack/test/cmd/env.py @@ -27,10 +27,12 @@ from spack.stage import stage_prefix from spack.util.mock_package import MockPackageMultiRepo from spack.util.path import substitute_path_variables +# TODO-27021 # everything here uses the mock_env_path pytestmark = [ pytest.mark.usefixtures('mutable_mock_env_path', 'config', 'mutable_mock_repo'), - pytest.mark.maybeslow + pytest.mark.maybeslow, + pytest.mark.skipif(sys.platform == 'win32', reason='Envs unsupported on Window') ] env = SpackCommand('env') @@ -42,10 +44,7 @@ stage = SpackCommand('stage') uninstall = SpackCommand('uninstall') find = SpackCommand('find') -if sys.platform == 'win32': - sep = 'C:\\' -else: - sep = os.sep +sep = os.sep def check_mpileaks_and_deps_in_view(viewdir): @@ -66,8 +65,6 @@ def test_add(): assert Spec('mpileaks') in e.user_specs -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_add_virtual(): env('create', 'test') @@ -136,8 +133,6 @@ def test_env_remove(capfd): assert 'bar' not in out -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_concretize(): e = ev.create('test') e.add('mpileaks') @@ -146,8 +141,6 @@ def test_concretize(): assert any(x.name == 'mpileaks' for x in env_specs) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="InstallError:Wrong cmake was in environment") def test_env_uninstalled_specs(install_mockery, mock_fetch): e = ev.create('test') e.add('cmake-client') @@ -161,8 +154,6 @@ def test_env_uninstalled_specs(install_mockery, mock_fetch): assert any(s.name == 'mpileaks' for s in e.uninstalled_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='InstallError: Wrong cmake was in environment') def test_env_install_all(install_mockery, mock_fetch): e = ev.create('test') e.add('cmake-client') @@ -173,8 +164,6 @@ def test_env_install_all(install_mockery, mock_fetch): assert spec.package.installed -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='InstallError: Wrong cmake was in environment') def test_env_install_single_spec(install_mockery, mock_fetch): env('create', 'test') install = SpackCommand('install') @@ -189,7 +178,6 @@ def test_env_install_single_spec(install_mockery, mock_fetch): assert e.specs_by_hash[e.concretized_order[0]].name == 'cmake-client' -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") def test_env_roots_marked_explicit(install_mockery, mock_fetch): install = SpackCommand('install') install('dependent-install') @@ -211,8 +199,6 @@ def test_env_roots_marked_explicit(install_mockery, mock_fetch): assert len(explicit) == 2 -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='InstallError: Wrong cmake was in environment') def test_env_modifications_error_on_activate( install_mockery, mock_fetch, monkeypatch, capfd): env('create', 'test') @@ -235,8 +221,6 @@ def test_env_modifications_error_on_activate( assert "Warning: couldn't get environment settings" in err -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Error: filename or extension is too long') def test_activate_adds_transitive_run_deps_to_path( install_mockery, mock_fetch, monkeypatch): env('create', 'test') @@ -251,8 +235,6 @@ def test_activate_adds_transitive_run_deps_to_path( assert env_variables['DEPENDENCY_ENV_VAR'] == '1' -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='InstallError: Wrong cmake was in environment:') def test_env_install_same_spec_twice(install_mockery, mock_fetch): env('create', 'test') @@ -267,8 +249,6 @@ def test_env_install_same_spec_twice(install_mockery, mock_fetch): assert 'already installed' in out -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_env_definition_symlink(install_mockery, mock_fetch, tmpdir): filepath = str(tmpdir.join('spack.yaml')) filepath_mid = str(tmpdir.join('spack_mid.yaml')) @@ -288,8 +268,6 @@ def test_env_definition_symlink(install_mockery, mock_fetch, tmpdir): assert os.path.islink(filepath_mid) -@pytest.mark.skipif(sys.platform == "win32", - reason='Logging error') def test_env_install_two_specs_same_dep( install_mockery, mock_fetch, tmpdir, capsys): """Test installation of two packages that share a dependency with no @@ -325,8 +303,6 @@ env: assert a, 'Expected a to be installed' -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_remove_after_concretize(): e = ev.create('test') @@ -350,8 +326,6 @@ def test_remove_after_concretize(): assert not any(s.name == 'mpileaks' for s in env_specs) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_remove_command(): env('create', 'test') assert 'test' in env('list') @@ -415,8 +389,6 @@ def test_environment_status(capsys, tmpdir): assert 'in current directory' in env('status') -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows - uses pkgconf') def test_env_status_broken_view( mutable_mock_env_path, mock_archive, mock_fetch, mock_packages, install_mockery, tmpdir @@ -438,8 +410,6 @@ def test_env_status_broken_view( assert 'includes out of date packages or repos' not in output -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows - uses pkgconf') def test_env_activate_broken_view( mutable_mock_env_path, mock_archive, mock_fetch, mock_packages, install_mockery @@ -458,8 +428,6 @@ def test_env_activate_broken_view( env('activate', '--sh', 'test') -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_to_lockfile_dict(): e = ev.create('test') e.add('mpileaks') @@ -472,8 +440,6 @@ def test_to_lockfile_dict(): assert e.specs_by_hash == e_copy.specs_by_hash -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_env_repo(): e = ev.create('test') e.add('mpileaks') @@ -487,8 +453,6 @@ def test_env_repo(): assert package.namespace == 'builtin.mock' -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_user_removed_spec(): """Ensure a user can remove from any position in the spack.yaml file.""" initial_yaml = StringIO("""\ @@ -523,8 +487,6 @@ env: assert not any(x.name == 'hypre' for x in env_specs) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_init_from_lockfile(tmpdir): """Test that an environment can be instantiated from a lockfile.""" initial_yaml = StringIO("""\ @@ -551,8 +513,6 @@ env: assert s1 == s2 -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_init_from_yaml(tmpdir): """Test that an environment can be instantiated from a lockfile.""" initial_yaml = StringIO("""\ @@ -576,8 +536,6 @@ env: assert not e2.specs_by_hash -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows - uses pkgconf') @pytest.mark.usefixtures('config') def test_env_view_external_prefix( tmpdir_factory, mutable_database, mock_packages @@ -650,8 +608,6 @@ env: assert 'test' not in out -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_with_config(): test_config = """\ env: @@ -671,8 +627,6 @@ env: for x in e._get_environment_specs()) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_with_config_bad_include(capfd): env_name = 'test_bad_include' test_config = """\ @@ -696,8 +650,6 @@ spack: assert ev.active_environment() is None -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_with_include_config_files_same_basename(): test_config = """\ env: @@ -740,8 +692,6 @@ def test_env_with_include_config_files_same_basename(): assert(environment_specs[1].satisfies('mpileaks@2.2')) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_with_included_config_file(): test_config = """\ env: @@ -767,8 +717,6 @@ packages: for x in e._get_environment_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_with_included_config_scope(): config_scope_path = os.path.join(ev.root('test'), 'config') test_config = """\ @@ -798,8 +746,6 @@ packages: for x in e._get_environment_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_with_included_config_var_path(): config_var_path = os.path.join('$tempdir', 'included-config.yaml') test_config = """\ @@ -829,8 +775,6 @@ packages: for x in e._get_environment_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_config_precedence(): test_config = """\ env: @@ -866,8 +810,6 @@ packages: x.satisfies('libelf@0.8.12') for x in e._get_environment_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_included_config_precedence(): test_config = """\ env: @@ -922,8 +864,6 @@ env: assert "'spacks' was unexpected" in str(e) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_loads(install_mockery, mock_fetch): env('create', 'test') @@ -945,8 +885,6 @@ def test_env_loads(install_mockery, mock_fetch): assert 'module load mpileaks' in contents -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") @pytest.mark.disable_clean_stage_check def test_stage(mock_stage, mock_fetch, install_mockery): env('create', 'test') @@ -985,8 +923,6 @@ def test_env_commands_die_with_no_env_arg(): env('status') -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_blocks_uninstall(mock_stage, mock_fetch, install_mockery): env('create', 'test') with ev.read('test'): @@ -1009,8 +945,6 @@ def test_roots_display_with_variants(): assert "boost +shared" in out -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_uninstall_removes_from_env(mock_stage, mock_fetch, install_mockery): env('create', 'test') with ev.read('test'): @@ -1053,8 +987,6 @@ def create_v1_lockfile_dict(roots, all_specs): return test_lockfile_dict -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows - uses pkgconf") @pytest.mark.usefixtures('config') def test_read_old_lock_and_write_new(tmpdir): build_only = ('build',) @@ -1086,8 +1018,6 @@ def test_read_old_lock_and_write_new(tmpdir): y.build_hash()]) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows - uses pkgconf") @pytest.mark.usefixtures('config') def test_read_old_lock_creates_backup(tmpdir): """When reading a version-1 lockfile, make sure that a backup of that file @@ -1116,8 +1046,6 @@ def test_read_old_lock_creates_backup(tmpdir): assert y.dag_hash() in lockfile_dict_v1['concrete_specs'] -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows - uses pkgconf") @pytest.mark.usefixtures('config') def test_indirect_build_dep(): """Simple case of X->Y->Z where Y is a build/link dep and Z is a @@ -1153,8 +1081,6 @@ def test_indirect_build_dep(): assert x_env_spec == x_concretized -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows - uses pkgconf") @pytest.mark.usefixtures('config') def test_store_different_build_deps(): r"""Ensure that an environment can store two instances of a build-only @@ -1208,8 +1134,6 @@ def test_store_different_build_deps(): assert x_read['z'] != y_read['z'] -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Fails on windows') def test_env_updates_view_install( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1221,8 +1145,6 @@ def test_env_updates_view_install( check_mpileaks_and_deps_in_view(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Fails on windows') def test_env_view_fails( tmpdir, mock_packages, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1235,8 +1157,6 @@ def test_env_view_fails( install('--fake') -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_without_view_install( tmpdir, mock_stage, mock_fetch, install_mockery): # Test enabling a view after installing specs @@ -1259,8 +1179,6 @@ def test_env_without_view_install( check_mpileaks_and_deps_in_view(view_dir) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_env_config_view_default( tmpdir, mock_stage, mock_fetch, install_mockery): # This config doesn't mention whether a view is enabled @@ -1280,8 +1198,6 @@ env: assert view.get_spec('mpileaks') -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_install_package( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1292,8 +1208,6 @@ def test_env_updates_view_install_package( assert os.path.exists(str(view_dir.join('.spack/mpileaks'))) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_add_concretize( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1306,8 +1220,6 @@ def test_env_updates_view_add_concretize( check_mpileaks_and_deps_in_view(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_uninstall( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1323,8 +1235,6 @@ def test_env_updates_view_uninstall( check_viewdir_removal(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_uninstall_referenced_elsewhere( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1342,8 +1252,6 @@ def test_env_updates_view_uninstall_referenced_elsewhere( check_viewdir_removal(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_remove_concretize( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1362,8 +1270,6 @@ def test_env_updates_view_remove_concretize( check_viewdir_removal(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_updates_view_force_remove( tmpdir, mock_stage, mock_fetch, install_mockery): view_dir = tmpdir.join('view') @@ -1379,8 +1285,6 @@ def test_env_updates_view_force_remove( check_viewdir_removal(view_dir) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason='Not supported on Windows (yet)') def test_env_activate_view_fails( tmpdir, mock_stage, mock_fetch, install_mockery): """Sanity check on env activate to make sure it requires shell support""" @@ -1455,8 +1359,6 @@ env: assert Spec('callpath^mpich@3.0.3') in test.user_specs -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") @pytest.mark.regression('12095') def test_stack_yaml_definitions_write_reference(tmpdir): filename = str(tmpdir.join('spack.yaml')) @@ -1523,8 +1425,6 @@ env: assert Spec('callpath') in test.user_specs -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_stack_yaml_remove_from_list_force(tmpdir): filename = str(tmpdir.join('spack.yaml')) with open(filename, 'w') as f: @@ -1575,8 +1475,6 @@ env: assert before == after -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_stack_yaml_force_remove_from_matrix(tmpdir): filename = str(tmpdir.join('spack.yaml')) with open(filename, 'w') as f: @@ -1610,8 +1508,6 @@ env: assert mpileaks_spec not in after_conc -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_stack_concretize_extraneous_deps(tmpdir, config, mock_packages): # FIXME: The new concretizer doesn't handle yet soft # FIXME: constraints for stacks @@ -1647,8 +1543,6 @@ env: assert concrete.satisfies('^mpi', strict=True) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_stack_concretize_extraneous_variants(tmpdir, config, mock_packages): filename = str(tmpdir.join('spack.yaml')) with open(filename, 'w') as f: @@ -1680,8 +1574,6 @@ env: user.variants['shared'].value) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_stack_concretize_extraneous_variants_with_dash(tmpdir, config, mock_packages): filename = str(tmpdir.join('spack.yaml')) @@ -1730,8 +1622,6 @@ env: assert Spec('callpath') in test.user_specs -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_definition_conditional_false(tmpdir): filename = str(tmpdir.join('spack.yaml')) with open(filename, 'w') as f: @@ -1889,8 +1779,6 @@ env: assert 'zmpi' not in packages_lists[1]['packages'] -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_combinatorial_view(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -1923,8 +1811,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_select(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -1963,8 +1849,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_exclude(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2003,8 +1887,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_select_and_exclude(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2044,8 +1926,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_view_link_roots(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2087,8 +1967,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_view_link_run(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): yaml = str(tmpdir.join('spack.yaml')) @@ -2120,8 +1998,6 @@ spack: assert not os.path.exists(os.path.join(viewdir, pkg)) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') @pytest.mark.parametrize('link_type', ['hardlink', 'copy', 'symlink']) def test_view_link_type(link_type, tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): @@ -2151,8 +2027,6 @@ env: assert os.path.islink(file_to_test) == (link_type == 'symlink') -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_view_link_all(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2193,8 +2067,6 @@ env: (spec.version, spec.compiler.name))) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_activate_from_default(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2226,8 +2098,6 @@ env: assert 'FOOBAR=mpileaks' in shell -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_no_activate_without_default(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): @@ -2258,8 +2128,6 @@ env: assert viewdir not in shell -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_stack_view_multiple_views(tmpdir, mock_fetch, mock_packages, mock_archive, install_mockery): filename = str(tmpdir.join('spack.yaml')) @@ -2362,8 +2230,6 @@ def test_env_activate_default_view_root_unconditional(mutable_mock_env_path): 'export PATH="{0}'.format(viewdir_bin) in out -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_concretize_user_specs_together(): e = ev.create('coconcretization') e.concretization = 'together' @@ -2392,8 +2258,6 @@ def test_concretize_user_specs_together(): assert all('mpich' not in spec for _, spec in e.concretized_specs()) -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_cant_install_single_spec_when_concretizing_together(): e = ev.create('coconcretization') e.concretization = 'together' @@ -2403,8 +2267,6 @@ def test_cant_install_single_spec_when_concretizing_together(): e.install_all() -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_duplicate_packages_raise_when_concretizing_together(): e = ev.create('coconcretization') e.concretization = 'together' @@ -2417,8 +2279,6 @@ def test_duplicate_packages_raise_when_concretizing_together(): e.concretize() -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") def test_env_write_only_non_default(): env('create', 'test') @@ -2429,8 +2289,6 @@ def test_env_write_only_non_default(): assert yaml == ev.default_manifest_yaml -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") @pytest.mark.regression('20526') def test_env_write_only_non_default_nested(tmpdir): # setup an environment file @@ -2465,8 +2323,6 @@ env: assert manifest == contents -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") @pytest.fixture def packages_yaml_v015(tmpdir): """Return the path to an existing manifest in the v0.15.x format @@ -2557,8 +2413,6 @@ spack: env('update', '-y', str(abspath.dirname)) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') @pytest.mark.regression('18338') def test_newline_in_commented_sequence_is_not_an_issue(tmpdir): spack_yaml = """ @@ -2594,8 +2448,6 @@ spack: assert libelf_first_hash == libelf_second_hash -@pytest.mark.skipif(str(spack.platforms.host()) == 'windows', - reason="Not supported on Windows (yet)") @pytest.mark.regression('18441') def test_lockfile_not_deleted_on_write_error(tmpdir, monkeypatch): raw_yaml = """ @@ -2729,8 +2581,6 @@ def test_custom_version_concretize_together(tmpdir): assert any('hdf5@myversion' in spec for _, spec in e.concretized_specs()) -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_modules_relative_to_views(tmpdir, install_mockery, mock_fetch): spack_yaml = """ spack: @@ -2762,8 +2612,6 @@ spack: assert spec.prefix not in contents -@pytest.mark.skipif(sys.platform == "win32", - reason='Not supported on Windows (yet)') def test_multiple_modules_post_env_hook(tmpdir, install_mockery, mock_fetch): spack_yaml = """ spack: diff --git a/lib/spack/spack/test/cmd/external.py b/lib/spack/spack/test/cmd/external.py index 3d7554c2eb..3a3c4face3 100644 --- a/lib/spack/spack/test/cmd/external.py +++ b/lib/spack/spack/test/cmd/external.py @@ -14,6 +14,8 @@ import spack.detection.path from spack.main import SpackCommand from spack.spec import Spec +is_windows = sys.platform == 'win32' + @pytest.fixture def executables_found(monkeypatch): @@ -25,11 +27,26 @@ def executables_found(monkeypatch): return _factory -@pytest.mark.skipif(sys.platform == 'win32', reason="Not yet implemented on windows") -def test_find_external_single_package(mock_executable, executables_found): +@pytest.fixture +def _platform_executables(monkeypatch): + def _win_exe_ext(): + return '.bat' + + monkeypatch.setattr(spack.package, 'win_exe_ext', _win_exe_ext) + + +def define_plat_exe(exe): + if is_windows: + exe += '.bat' + return exe + + +def test_find_external_single_package(mock_executable, executables_found, + _platform_executables): pkgs_to_check = [spack.repo.get('cmake')] executables_found({ - mock_executable("cmake", output='echo "cmake version 1.foo"'): 'cmake' + mock_executable("cmake", output='echo cmake version 1.foo'): + define_plat_exe('cmake') }) pkg_to_entries = spack.detection.by_executable(pkgs_to_check) @@ -40,20 +57,23 @@ def test_find_external_single_package(mock_executable, executables_found): assert single_entry.spec == Spec('cmake@1.foo') -@pytest.mark.skipif(sys.platform == 'win32', reason="Not yet implemented on windows") -def test_find_external_two_instances_same_package(mock_executable, executables_found): +def test_find_external_two_instances_same_package(mock_executable, executables_found, + _platform_executables): pkgs_to_check = [spack.repo.get('cmake')] # Each of these cmake instances is created in a different prefix + # In Windows, quoted strings are echo'd with quotes includes + # we need to avoid that for proper regex. cmake_path1 = mock_executable( - "cmake", output='echo "cmake version 1.foo"', subdir=('base1', 'bin') + "cmake", output='echo cmake version 1.foo', subdir=('base1', 'bin') ) cmake_path2 = mock_executable( - "cmake", output='echo "cmake version 3.17.2"', subdir=('base2', 'bin') + "cmake", output='echo cmake version 3.17.2', subdir=('base2', 'bin') ) + cmake_exe = define_plat_exe('cmake') executables_found({ - cmake_path1: 'cmake', - cmake_path2: 'cmake' + cmake_path1: cmake_exe, + cmake_path2: cmake_exe }) pkg_to_entries = spack.detection.by_executable(pkgs_to_check) @@ -87,23 +107,24 @@ def test_find_external_update_config(mutable_config): def test_get_executables(working_env, mock_executable): cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo") - os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)]) + os.environ['PATH'] = os.pathsep.join([os.path.dirname(cmake_path1)]) path_to_exe = spack.detection.executables_in_path() - assert path_to_exe[cmake_path1] == 'cmake' + cmake_exe = define_plat_exe('cmake') + assert path_to_exe[cmake_path1] == cmake_exe external = SpackCommand('external') -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") -def test_find_external_cmd(mutable_config, working_env, mock_executable): +def test_find_external_cmd(mutable_config, working_env, mock_executable, + _platform_executables): """Test invoking 'spack external find' with additional package arguments, which restricts the set of packages that Spack looks for. """ cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo") prefix = os.path.dirname(os.path.dirname(cmake_path1)) - os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)]) + os.environ['PATH'] = os.pathsep.join([os.path.dirname(cmake_path1)]) external('find', 'cmake') pkgs_cfg = spack.config.get('packages') @@ -113,7 +134,6 @@ def test_find_external_cmd(mutable_config, working_env, mock_executable): assert {'spec': 'cmake@1.foo', 'prefix': prefix} in cmake_externals -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_find_external_cmd_not_buildable( mutable_config, working_env, mock_executable): """When the user invokes 'spack external find --not-buildable', the config @@ -121,25 +141,23 @@ def test_find_external_cmd_not_buildable( not buildable. """ cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo") - os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)]) + os.environ['PATH'] = os.pathsep.join([os.path.dirname(cmake_path1)]) external('find', '--not-buildable', 'cmake') pkgs_cfg = spack.config.get('packages') assert not pkgs_cfg['cmake']['buildable'] -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_find_external_cmd_full_repo( - mutable_config, working_env, mock_executable, mutable_mock_repo): - """Test invoking 'spack external find --all' with no additional arguments + mutable_config, working_env, mock_executable, mutable_mock_repo, + _platform_executables): + """Test invoking 'spack external find' with no additional arguments, which iterates through each package in the repository. """ - exe_path1 = mock_executable( "find-externals1-exe", output="echo find-externals1 version 1.foo" ) prefix = os.path.dirname(os.path.dirname(exe_path1)) - - os.environ['PATH'] = ':'.join([os.path.dirname(exe_path1)]) + os.environ['PATH'] = os.pathsep.join([os.path.dirname(exe_path1)]) external('find', '--all') pkgs_cfg = spack.config.get('packages') @@ -186,14 +204,13 @@ def test_find_external_merge(mutable_config, mutable_mock_repo): 'prefix': '/x/y2/'} in pkg_externals -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_detectable_packages(mutable_config, mutable_mock_repo): external("list") assert external.returncode == 0 -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") -def test_packages_yaml_format(mock_executable, mutable_config, monkeypatch): +def test_packages_yaml_format( + mock_executable, mutable_config, monkeypatch, _platform_executables): # Prepare an environment to detect a fake gcc gcc_exe = mock_executable('gcc', output="echo 4.2.1") prefix = os.path.dirname(gcc_exe) @@ -217,8 +234,8 @@ def test_packages_yaml_format(mock_executable, mutable_config, monkeypatch): assert extra_attributes['compilers']['c'] == gcc_exe -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") -def test_overriding_prefix(mock_executable, mutable_config, monkeypatch): +def test_overriding_prefix( + mock_executable, mutable_config, monkeypatch, _platform_executables): # Prepare an environment to detect a fake gcc that # override its external prefix gcc_exe = mock_executable('gcc', output="echo 4.2.1") @@ -247,9 +264,8 @@ def test_overriding_prefix(mock_executable, mutable_config, monkeypatch): assert externals[0]['prefix'] == '/opt/gcc/bin' -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_new_entries_are_reported_correctly( - mock_executable, mutable_config, monkeypatch + mock_executable, mutable_config, monkeypatch, _platform_executables ): # Prepare an environment to detect a fake gcc gcc_exe = mock_executable('gcc', output="echo 4.2.1") @@ -266,7 +282,6 @@ def test_new_entries_are_reported_correctly( assert 'No new external packages detected' in output -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") @pytest.mark.parametrize('command_args', [ ('-t', 'build-tools'), ('-t', 'build-tools', 'cmake'), diff --git a/lib/spack/spack/test/cmd/fetch.py b/lib/spack/spack/test/cmd/fetch.py index 323fd06cd2..da56fbd528 100644 --- a/lib/spack/spack/test/cmd/fetch.py +++ b/lib/spack/spack/test/cmd/fetch.py @@ -3,18 +3,15 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) -import sys - import pytest import spack.environment as ev from spack.main import SpackCommand, SpackCommandError # everything here uses the mock_env_path -pytestmark = [pytest.mark.usefixtures( - "mutable_mock_env_path", "config", "mutable_mock_repo"), - pytest.mark.skipif(sys.platform == "win32", - reason="does not run on windows")] +pytestmark = pytest.mark.usefixtures( + "mutable_mock_env_path", "config", "mutable_mock_repo" +) @pytest.mark.disable_clean_stage_check diff --git a/lib/spack/spack/test/cmd/info.py b/lib/spack/spack/test/cmd/info.py index dada99d1dd..9d240628b4 100644 --- a/lib/spack/spack/test/cmd/info.py +++ b/lib/spack/spack/test/cmd/info.py @@ -13,6 +13,9 @@ from spack.main import SpackCommand info = SpackCommand('info') +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Not yet implemented on Windows") + @pytest.fixture(scope='module') def parser(): @@ -37,7 +40,6 @@ def mock_print(monkeypatch, info_lines): monkeypatch.setattr(spack.cmd.info.color, 'cprint', _print, raising=False) -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") @pytest.mark.parametrize('pkg', [ 'openmpi', 'trilinos', @@ -50,7 +52,6 @@ def test_it_just_runs(pkg): info(pkg) -@pytest.mark.skipif(sys.platform == 'win32', reason="Not yet implemented on windows") def test_info_noversion(mock_packages, info_lines, mock_print): """Check that a mock package with no versions or variants outputs None.""" info('noversion') @@ -83,7 +84,6 @@ def test_is_externally_detectable(pkg_query, expected, parser, info_lines): assert is_externally_detectable == expected -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") @pytest.mark.parametrize('pkg_query', [ 'hdf5', 'cloverleaf3d', diff --git a/lib/spack/spack/test/cmd/is_git_repo.py b/lib/spack/spack/test/cmd/is_git_repo.py index 7cb0dc2694..025d04fff0 100644 --- a/lib/spack/spack/test/cmd/is_git_repo.py +++ b/lib/spack/spack/test/cmd/is_git_repo.py @@ -45,6 +45,10 @@ def git_tmp_worktree(tmpdir): """Create new worktree in a temporary folder and monkeypatch spack.paths.prefix to point to it. """ + # TODO: This is fragile and should be high priority for + # follow up fixes. 27021 + # Path length is occasionally too long on Windows + # the following reduces the path length to acceptable levels if sys.platform == 'win32': long_pth = str(tmpdir).split(os.path.sep) tmp_worktree = os.path.sep.join(long_pth[:-1]) diff --git a/lib/spack/spack/test/cmd/list.py b/lib/spack/spack/test/cmd/list.py index 42253eb354..fe86a7f3b7 100644 --- a/lib/spack/spack/test/cmd/list.py +++ b/lib/spack/spack/test/cmd/list.py @@ -3,23 +3,17 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) -import sys - -import pytest - from spack.main import SpackCommand list = SpackCommand('list') -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list(): output = list() assert 'cloverleaf3d' in output assert 'hdf5' in output -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_filter(mock_packages): output = list('py-*') assert 'py-extension1' in output @@ -36,20 +30,17 @@ def test_list_filter(mock_packages): assert 'mpich' not in output -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_search_description(mock_packages): output = list('--search-description', 'one build dependency') assert 'depb' in output -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_format_name_only(mock_packages): output = list('--format', 'name_only') assert 'zmpi' in output assert 'hdf5' in output -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_format_version_json(mock_packages): output = list('--format', 'version_json') assert '{"name": "zmpi",' in output @@ -58,7 +49,6 @@ def test_list_format_version_json(mock_packages): json.loads(output) -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_list_format_html(mock_packages): output = list('--format', 'html') assert '<div class="section" id="zmpi">' in output diff --git a/lib/spack/spack/test/cmd/mirror.py b/lib/spack/spack/test/cmd/mirror.py index 317febdd7b..0027b4ae2b 100644 --- a/lib/spack/spack/test/cmd/mirror.py +++ b/lib/spack/spack/test/cmd/mirror.py @@ -43,6 +43,15 @@ def tmp_scope(): yield scope_name +def _validate_url(url): + return + + +@pytest.fixture(autouse=True) +def url_check(monkeypatch): + monkeypatch.setattr(spack.util.url, 'require_url_format', _validate_url) + + @pytest.mark.disable_clean_stage_check @pytest.mark.regression('8083') def test_regression_8083(tmpdir, capfd, mock_packages, mock_fetch, config): diff --git a/lib/spack/spack/test/cmd/pkg.py b/lib/spack/spack/test/cmd/pkg.py index 1924fbccb8..7f681ad9b9 100644 --- a/lib/spack/spack/test/cmd/pkg.py +++ b/lib/spack/spack/test/cmd/pkg.py @@ -105,7 +105,6 @@ def split(output): pkg = spack.main.SpackCommand('pkg') -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") def test_packages_path(): assert (spack.cmd.pkg.packages_path() == spack.repo.path.get_repo('builtin').packages_path) @@ -139,6 +138,7 @@ def test_pkg_add(mock_pkg_git_repo): pkg('add', 'does-not-exist') +@pytest.mark.skipif(sys.platform == 'win32', reason="stdout format conflict") def test_pkg_list(mock_pkg_git_repo, mock_pkg_names): out = split(pkg('list', 'HEAD^^')) assert sorted(mock_pkg_names) == sorted(out) @@ -156,6 +156,7 @@ def test_pkg_list(mock_pkg_git_repo, mock_pkg_names): assert sorted(mock_pkg_names) == sorted(out) +@pytest.mark.skipif(sys.platform == 'win32', reason="stdout format conflict") def test_pkg_diff(mock_pkg_git_repo, mock_pkg_names): out = split(pkg('diff', 'HEAD^^', 'HEAD^')) assert out == ['HEAD^:', 'pkg-a', 'pkg-b', 'pkg-c'] @@ -167,20 +168,22 @@ def test_pkg_diff(mock_pkg_git_repo, mock_pkg_names): assert out == ['HEAD^:', 'pkg-c', 'HEAD:', 'pkg-d'] +@pytest.mark.skipif(sys.platform == 'win32', reason="stdout format conflict") def test_pkg_added(mock_pkg_git_repo): out = split(pkg('added', 'HEAD^^', 'HEAD^')) - assert out == ['pkg-a', 'pkg-b', 'pkg-c'] + assert ['pkg-a', 'pkg-b', 'pkg-c'] == out out = split(pkg('added', 'HEAD^^', 'HEAD')) - assert out == ['pkg-a', 'pkg-b', 'pkg-d'] + assert ['pkg-a', 'pkg-b', 'pkg-d'] == out out = split(pkg('added', 'HEAD^', 'HEAD')) - assert out == ['pkg-d'] + assert ['pkg-d'] == out out = split(pkg('added', 'HEAD', 'HEAD')) assert out == [] +@pytest.mark.skipif(sys.platform == 'win32', reason="stdout format conflict") def test_pkg_removed(mock_pkg_git_repo): out = split(pkg('removed', 'HEAD^^', 'HEAD^')) assert out == [] @@ -192,7 +195,7 @@ def test_pkg_removed(mock_pkg_git_repo): assert out == ['pkg-c'] -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") +@pytest.mark.skipif(sys.platform == 'win32', reason="stdout format conflict") def test_pkg_changed(mock_pkg_git_repo): out = split(pkg('changed', 'HEAD^^', 'HEAD^')) assert out == [] diff --git a/lib/spack/spack/test/cmd/providers.py b/lib/spack/spack/test/cmd/providers.py index cc6b3068ed..44d56ca1a1 100644 --- a/lib/spack/spack/test/cmd/providers.py +++ b/lib/spack/spack/test/cmd/providers.py @@ -12,8 +12,10 @@ from spack.main import SpackCommand providers = SpackCommand('providers') +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Providers not currently supported on Windows") + -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") @pytest.mark.parametrize('pkg', [ ('mpi',), ('mpi@2',), @@ -24,7 +26,6 @@ def test_it_just_runs(pkg): providers(*pkg) -@pytest.mark.skipif(sys.platform == 'win32', reason="Error on Win") @pytest.mark.parametrize('vpkg,provider_list', [ (('mpi',), ['intel-mpi', 'intel-parallel-studio', diff --git a/lib/spack/spack/test/cmd/resource.py b/lib/spack/spack/test/cmd/resource.py index 04e7e0e325..64a79fd601 100644 --- a/lib/spack/spack/test/cmd/resource.py +++ b/lib/spack/spack/test/cmd/resource.py @@ -2,12 +2,12 @@ # Spack Project Developers. See the top-level COPYRIGHT file for details. # # SPDX-License-Identifier: (Apache-2.0 OR MIT) +import os import sys -import pytest - from spack.main import SpackCommand +is_windows = sys.platform == 'win32' resource = SpackCommand('resource') #: these are hashes used in mock packages @@ -22,11 +22,17 @@ mock_hashes = [ '208fcfb50e5a965d5757d151b675ca4af4ce2dfd56401721b6168fae60ab798f', 'bf07a7fbb825fc0aae7bf4a1177b2b31fcf8a3feeaf7092761e18c859ee52a9c', '7d865e959b2466918c9863afca942d0fb89d7c9ac0c99bafc3749504ded97730', +] if not is_windows else [ + 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234', + '1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd', + 'd0df7988457ec999c148a4a2af25ce831bfaad13954ba18a4446374cb0aef55e', + 'aeb16c4dec1087e39f2330542d59d9b456dd26d791338ae6d80b6ffd10c89dfa', + 'mid21234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234', + 'ff34cb21271d16dbf928374f610bb5dd593d293d311036ddae86c4846ff79070', + 'bf874c7dd3a83cf370fdc17e496e341de06cd596b5c66dbf3c9bb7f6c139e3ee', + '3c5b65abcd6a3b2c714dbf7c31ff65fe3748a1adc371f030c283007ca5534f11' ] -pytestmark = pytest.mark.skipif(sys.platform == "win32", - reason="does not run on windows") - def test_resource_list(mock_packages, capfd): with capfd.disabled(): @@ -40,7 +46,8 @@ def test_resource_list(mock_packages, capfd): assert 'patched by:' in out assert 'path:' in out - assert 'repos/builtin.mock/packages/patch-a-dependency/libelf.patch' in out + assert os.path.join('repos', 'builtin.mock', 'packages', + 'patch-a-dependency', 'libelf.patch') in out assert 'applies to: builtin.mock.libelf' in out assert 'patched by: builtin.mock.patch-a-dependency' in out @@ -54,11 +61,19 @@ def test_resource_list_only_hashes(mock_packages, capfd): def test_resource_show(mock_packages, capfd): + test_hash = 'c45c1564f70def3fc1a6e22139f62cb21cd190cc3a7dbe6f4120fa59ce33dcb8' \ + if not is_windows \ + else '3c5b65abcd6a3b2c714dbf7c31ff65fe3748a1adc371f030c283007ca5534f11' with capfd.disabled(): - out = resource('show', 'c45c1564f70def3fc1a6e22139f62cb21cd190cc3a7dbe6f4120fa59ce33dcb8') - - assert out.startswith('c45c1564f70def3fc1a6e22139f62cb21cd190cc3a7dbe6f4120fa59ce33dcb8') - assert 'repos/builtin.mock/packages/patch-a-dependency/libelf.patch' in out + out = resource('show', test_hash) + + assert out.startswith(test_hash) + assert os.path.join( + 'repos', + 'builtin.mock', + 'packages', + 'patch-a-dependency', + 'libelf.patch') in out assert 'applies to: builtin.mock.libelf' in out assert 'patched by: builtin.mock.patch-a-dependency' in out diff --git a/lib/spack/spack/test/cmd/test.py b/lib/spack/spack/test/cmd/test.py index ad631db899..0f8e707376 100644 --- a/lib/spack/spack/test/cmd/test.py +++ b/lib/spack/spack/test/cmd/test.py @@ -234,7 +234,7 @@ def test_test_list( reason="Not supported on Windows (yet)") def test_has_test_method_fails(capsys): with pytest.raises(SystemExit): - has_test_method('printing-package') + spack.package.has_test_method('printing-package') captured = capsys.readouterr()[1] assert 'is not a class' in captured diff --git a/lib/spack/spack/test/cmd/uninstall.py b/lib/spack/spack/test/cmd/uninstall.py index 0ce3a260e6..857f1ae35d 100644 --- a/lib/spack/spack/test/cmd/uninstall.py +++ b/lib/spack/spack/test/cmd/uninstall.py @@ -13,9 +13,6 @@ from spack.main import SpackCommand, SpackCommandError uninstall = SpackCommand('uninstall') install = SpackCommand('install') -# pytestmark = pytest.mark.skipif(sys.platform == "win32", -# reason="does not run on windows") - class MockArgs(object): diff --git a/lib/spack/spack/test/cmd_extensions.py b/lib/spack/spack/test/cmd_extensions.py index d7e0538ce1..dbe79e603a 100644 --- a/lib/spack/spack/test/cmd_extensions.py +++ b/lib/spack/spack/test/cmd_extensions.py @@ -14,6 +14,8 @@ import spack.config import spack.extensions import spack.main +is_windows = sys.platform == 'win32' + class Extension: """Helper class to simplify the creation of simple command extension @@ -259,12 +261,14 @@ def test_get_command_paths(config): def test_variable_in_extension_path(config, working_env): """Test variables in extension paths.""" - os.environ['_MY_VAR'] = "my/var" + os.environ['_MY_VAR'] = os.path.join('my', 'var') ext_paths = [ os.path.join("~", "${_MY_VAR}", "spack-extension-1") ] + # Home env variable is USERPROFILE on Windows + home_env = 'USERPROFILE' if is_windows else 'HOME' expected_ext_paths = [ - os.path.join(os.environ['HOME'], os.environ['_MY_VAR'], "spack-extension-1") + os.path.join(os.environ[home_env], os.environ['_MY_VAR'], "spack-extension-1") ] with spack.config.override('config:extensions', ext_paths): assert spack.extensions.get_extension_paths() == expected_ext_paths diff --git a/lib/spack/spack/test/concretize.py b/lib/spack/spack/test/concretize.py index 73da1ccbab..f47dc58073 100644 --- a/lib/spack/spack/test/concretize.py +++ b/lib/spack/spack/test/concretize.py @@ -2,6 +2,7 @@ # Spack Project Developers. See the top-level COPYRIGHT file for details. # # SPDX-License-Identifier: (Apache-2.0 OR MIT) +import os import sys import jinja2 @@ -22,8 +23,7 @@ from spack.spec import Spec from spack.util.mock_package import MockPackageMultiRepo from spack.version import ver -pytestmark = pytest.mark.skipif(sys.platform == "win32", - reason="does not run on windows") +is_windows = sys.platform == 'win32' def check_spec(abstract, concrete): @@ -370,6 +370,7 @@ class TestConcretize(object): with pytest.raises(spack.error.SpackError): s.concretize() + @pytest.mark.skipif(sys.platform == 'win32', reason='No Compiler for Arch on Win') def test_no_matching_compiler_specs(self, mock_low_high_config): # only relevant when not building compilers as needed with spack.concretize.enable_compiler_existence_check(): @@ -435,15 +436,17 @@ class TestConcretize(object): def test_external_package(self): spec = Spec('externaltool%gcc') spec.concretize() - assert spec['externaltool'].external_path == '/path/to/external_tool' + assert spec['externaltool'].external_path == \ + os.path.sep + os.path.join('path', 'to', 'external_tool') assert 'externalprereq' not in spec assert spec['externaltool'].compiler.satisfies('gcc') def test_external_package_module(self): # No tcl modules on darwin/linux machines + # and Windows does not (currently) allow for bash calls # TODO: improved way to check for this. platform = spack.platforms.real_host().name - if platform == 'darwin' or platform == 'linux': + if platform == 'darwin' or platform == 'linux' or platform == 'windows': return spec = Spec('externalmodule') @@ -463,8 +466,10 @@ class TestConcretize(object): def test_external_and_virtual(self): spec = Spec('externaltest') spec.concretize() - assert spec['externaltool'].external_path == '/path/to/external_tool' - assert spec['stuff'].external_path == '/path/to/external_virtual_gcc' + assert spec['externaltool'].external_path == \ + os.path.sep + os.path.join('path', 'to', 'external_tool') + assert spec['stuff'].external_path == \ + os.path.sep + os.path.join('path', 'to', 'external_virtual_gcc') assert spec['externaltool'].compiler.satisfies('gcc') assert spec['stuff'].compiler.satisfies('gcc') @@ -707,6 +712,8 @@ class TestConcretize(object): with pytest.raises(spack.error.SpackError): Spec(spec).concretized() + @pytest.mark.skipif(sys.platform == 'win32', + reason="Not supported on Windows (yet)") # Include targets to prevent regression on 20537 @pytest.mark.parametrize('spec, best_achievable', [ ('mpileaks%gcc@4.4.7 ^dyninst@10.2.1 target=x86_64:', 'core2'), @@ -1116,7 +1123,7 @@ class TestConcretize(object): assert '%gcc@foo' in s def test_all_patches_applied(self): - uuidpatch = 'a60a42b73e03f207433c5579de207c6ed61d58e4d12dd3b5142eb525728d89ea' + uuidpatch = 'a60a42b73e03f207433c5579de207c6ed61d58e4d12dd3b5142eb525728d89ea' if not is_windows else 'd0df7988457ec999c148a4a2af25ce831bfaad13954ba18a4446374cb0aef55e' localpatch = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' spec = spack.spec.Spec('conditionally-patch-dependency+jasper') spec.concretize() diff --git a/lib/spack/spack/test/concretize_preferences.py b/lib/spack/spack/test/concretize_preferences.py index 75aa3e813c..525bd0701f 100644 --- a/lib/spack/spack/test/concretize_preferences.py +++ b/lib/spack/spack/test/concretize_preferences.py @@ -5,7 +5,6 @@ import os import stat -import sys import pytest diff --git a/lib/spack/spack/test/config.py b/lib/spack/spack/test/config.py index 1ab9c48eaa..a765582a2b 100644 --- a/lib/spack/spack/test/config.py +++ b/lib/spack/spack/test/config.py @@ -92,6 +92,13 @@ env: return env_yaml +def cross_plat_join(*pths): + """os.path.join does not prepend paths to other paths + beginning with a Windows drive label i.e. D:\\ + """ + return os.sep.join([pth for pth in pths]) + + def check_compiler_config(comps, *compiler_names): """Check that named compilers in comps match Spack's config.""" config = spack.config.get('compilers') @@ -334,65 +341,66 @@ class MockEnv(object): self.path = path -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_substitute_config_variables(mock_low_high_config, monkeypatch): prefix = spack.paths.prefix.lstrip('/') - - assert os.path.join( - '/foo/bar/baz', prefix + assert cross_plat_join( + os.sep + os.path.join('foo', 'bar', 'baz'), prefix ) == spack_path.canonicalize_path('/foo/bar/baz/$spack') - assert os.path.join( - spack.paths.prefix, 'foo/bar/baz' + assert cross_plat_join( + spack.paths.prefix, os.path.join('foo', 'bar', 'baz') ) == spack_path.canonicalize_path('$spack/foo/bar/baz/') - assert os.path.join( - '/foo/bar/baz', prefix, 'foo/bar/baz' + assert cross_plat_join( + os.sep + os.path.join('foo', 'bar', 'baz'), + prefix, os.path.join('foo', 'bar', 'baz') ) == spack_path.canonicalize_path('/foo/bar/baz/$spack/foo/bar/baz/') - assert os.path.join( - '/foo/bar/baz', prefix + assert cross_plat_join( + os.sep + os.path.join('foo', 'bar', 'baz'), prefix ) == spack_path.canonicalize_path('/foo/bar/baz/${spack}') - assert os.path.join( - spack.paths.prefix, 'foo/bar/baz' + assert cross_plat_join( + spack.paths.prefix, os.path.join('foo', 'bar', 'baz') ) == spack_path.canonicalize_path('${spack}/foo/bar/baz/') - assert os.path.join( - '/foo/bar/baz', prefix, 'foo/bar/baz' + assert cross_plat_join( + os.sep + os.path.join('foo', 'bar', 'baz'), + prefix, os.path.join('foo', 'bar', 'baz') ) == spack_path.canonicalize_path('/foo/bar/baz/${spack}/foo/bar/baz/') - assert os.path.join( - '/foo/bar/baz', prefix, 'foo/bar/baz' + assert cross_plat_join( + os.sep + os.path.join('foo', 'bar', 'baz'), + prefix, os.path.join('foo', 'bar', 'baz') ) != spack_path.canonicalize_path('/foo/bar/baz/${spack/foo/bar/baz/') # $env replacement is a no-op when no environment is active assert spack_path.canonicalize_path( - '/foo/bar/baz/$env' - ) == '/foo/bar/baz/$env' + os.sep + os.path.join('foo', 'bar', 'baz', '$env') + ) == os.sep + os.path.join('foo', 'bar', 'baz', '$env') # Fake an active environment and $env is replaced properly - fake_env_path = '/quux/quuux' + fake_env_path = os.sep + os.path.join('quux', 'quuux') monkeypatch.setattr(ev, 'active_environment', lambda: MockEnv(fake_env_path)) assert spack_path.canonicalize_path( '$env/foo/bar/baz' - ) == os.path.join(fake_env_path, 'foo/bar/baz') + ) == os.path.join(fake_env_path, os.path.join('foo', 'bar', 'baz')) # relative paths without source information are relative to cwd assert spack_path.canonicalize_path( - 'foo/bar/baz' - ) == os.path.abspath('foo/bar/baz') + os.path.join('foo', 'bar', 'baz') + ) == os.path.abspath(os.path.join('foo', 'bar', 'baz')) # relative paths with source information are relative to the file spack.config.set( - 'modules:default', {'roots': {'lmod': 'foo/bar/baz'}}, scope='low') + 'modules:default', + {'roots': {'lmod': os.path.join('foo', 'bar', 'baz')}}, scope='low') spack.config.config.clear_caches() path = spack.config.get('modules:default:roots:lmod') assert spack_path.canonicalize_path(path) == os.path.normpath( os.path.join(mock_low_high_config.scopes['low'].path, - 'foo/bar/baz')) + os.path.join('foo', 'bar', 'baz'))) packages_merge_low = { @@ -439,41 +447,29 @@ def test_merge_with_defaults(mock_low_high_config, write_config_file): assert cfg['baz']['version'] == ['c'] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_substitute_user(mock_low_high_config): user = getpass.getuser() - assert '/foo/bar/' + user + '/baz' == spack_path.canonicalize_path( - '/foo/bar/$user/baz' - ) - - -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") -def test_substitute_user_config(mock_low_high_config): - user_config_path = spack.paths.user_config_path - assert user_config_path + '/baz' == spack_path.canonicalize_path( - '$user_cache_path/baz' + assert os.sep + os.path.join('foo', 'bar') + os.sep \ + + user + os.sep \ + + 'baz' == spack_path.canonicalize_path( + os.sep + os.path.join('foo', 'bar', '$user', 'baz') ) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_substitute_user_cache(mock_low_high_config): user_cache_path = spack.paths.user_cache_path - assert user_cache_path + '/baz' == spack_path.canonicalize_path( - '$user_cache_path/baz' + assert user_cache_path + os.sep + 'baz' == spack_path.canonicalize_path( + os.path.join('$user_cache_path', 'baz') ) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_substitute_tempdir(mock_low_high_config): tempdir = tempfile.gettempdir() assert tempdir == spack_path.canonicalize_path('$tempdir') - assert tempdir + '/foo/bar/baz' == spack_path.canonicalize_path( - '$tempdir/foo/bar/baz' - ) + assert tempdir + os.sep + \ + os.path.join('foo', 'bar', 'baz') == spack_path.canonicalize_path( + os.path.join('$tempdir', 'foo', 'bar', 'baz') + ) PAD_STRING = spack.util.path.SPACK_PATH_PADDING_CHARS @@ -481,36 +477,57 @@ MAX_PATH_LEN = spack.util.path.get_system_path_max() MAX_PADDED_LEN = MAX_PATH_LEN - spack.util.path.SPACK_MAX_INSTALL_PATH_LENGTH reps = [PAD_STRING for _ in range((MAX_PADDED_LEN // len(PAD_STRING) + 1) + 2)] full_padded_string = os.path.join( - '/path', os.path.sep.join(reps))[:MAX_PADDED_LEN] + os.sep + 'path', os.sep.join(reps))[:MAX_PADDED_LEN] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('config_settings,expected', [ ([], [None, None, None]), - ([['config:install_tree:root', '/path']], ['/path', None, None]), - ([['config:install_tree', '/path']], ['/path', None, None]), + ([['config:install_tree:root', os.sep + 'path']], [os.sep + 'path', None, None]), + ([['config:install_tree', os.sep + 'path']], [os.sep + 'path', None, None]), ([['config:install_tree:projections', {'all': '{name}'}]], [None, None, {'all': '{name}'}]), ([['config:install_path_scheme', '{name}']], [None, None, {'all': '{name}'}]), - ([['config:install_tree:root', '/path'], +]) +def test_parse_install_tree(config_settings, expected, mutable_config): + expected_root = expected[0] or spack.store.default_install_tree_root + expected_unpadded_root = expected[1] or expected_root + expected_proj = expected[2] or spack.directory_layout.default_projections + + # config settings is a list of 2-element lists, [path, value] + # where path is a config path and value is the value to set at that path + # these can be "splatted" in as the arguments to config.set + for config_setting in config_settings: + mutable_config.set(*config_setting) + + config_dict = mutable_config.get('config') + root, unpadded_root, projections = spack.store.parse_install_tree( + config_dict) + assert root == expected_root + assert unpadded_root == expected_unpadded_root + assert projections == expected_proj + + +@pytest.mark.skipif(sys.platform == 'win32', + reason='Padding unsupported on Windows') +@pytest.mark.parametrize('config_settings,expected', [ + ([['config:install_tree:root', os.sep + 'path'], ['config:install_tree:padded_length', 11]], - [os.path.join('/path', PAD_STRING[:5]), '/path', None]), + [os.path.join(os.sep + 'path', PAD_STRING[:5]), os.sep + 'path', None]), ([['config:install_tree:root', '/path/$padding:11']], - [os.path.join('/path', PAD_STRING[:5]), '/path', None]), + [os.path.join(os.sep + 'path', PAD_STRING[:5]), os.sep + 'path', None]), ([['config:install_tree', '/path/${padding:11}']], - [os.path.join('/path', PAD_STRING[:5]), '/path', None]), + [os.path.join(os.sep + 'path', PAD_STRING[:5]), os.sep + 'path', None]), ([['config:install_tree:padded_length', False]], [None, None, None]), ([['config:install_tree:padded_length', True], - ['config:install_tree:root', '/path']], - [full_padded_string, '/path', None]), - ([['config:install_tree:', '/path$padding']], - [full_padded_string, '/path', None]), - ([['config:install_tree:', '/path/${padding}']], - [full_padded_string, '/path', None]), + ['config:install_tree:root', os.sep + 'path']], + [full_padded_string, os.sep + 'path', None]), + ([['config:install_tree:', os.sep + 'path$padding']], + [full_padded_string, os.sep + 'path', None]), + ([['config:install_tree:', os.sep + 'path' + os.sep + '${padding}']], + [full_padded_string, os.sep + 'path', None]), ]) -def test_parse_install_tree(config_settings, expected, mutable_config): +def test_parse_install_tree_padded(config_settings, expected, mutable_config): expected_root = expected[0] or spack.store.default_install_tree_root expected_unpadded_root = expected[1] or expected_root expected_proj = expected[2] or spack.directory_layout.default_projections @@ -524,7 +541,6 @@ def test_parse_install_tree(config_settings, expected, mutable_config): config_dict = mutable_config.get('config') root, unpadded_root, projections = spack.store.parse_install_tree( config_dict) - assert root == expected_root assert unpadded_root == expected_unpadded_root assert projections == expected_proj @@ -1217,7 +1233,8 @@ def test_system_config_path_is_overridable(working_env): def test_system_config_path_is_default_when_env_var_is_empty(working_env): os.environ['SPACK_SYSTEM_CONFIG_PATH'] = '' - assert "/etc/spack" == spack.paths._get_system_config_path() + assert os.sep + os.path.join('etc', 'spack') == \ + spack.paths._get_system_config_path() def test_user_config_path_is_overridable(working_env): @@ -1228,7 +1245,8 @@ def test_user_config_path_is_overridable(working_env): def test_user_config_path_is_default_when_env_var_is_empty(working_env): os.environ['SPACK_USER_CONFIG_PATH'] = '' - assert os.path.expanduser("~/.spack") == spack.paths._get_user_config_path() + assert os.path.expanduser("~%s.spack" % os.sep) == \ + spack.paths._get_user_config_path() def test_local_config_can_be_disabled(working_env): @@ -1262,4 +1280,5 @@ def test_user_cache_path_is_overridable(working_env): def test_user_cache_path_is_default_when_env_var_is_empty(working_env): os.environ['SPACK_USER_CACHE_PATH'] = '' - assert os.path.expanduser("~/.spack") == spack.paths._get_user_cache_path() + assert os.path.expanduser("~%s.spack" % os.sep) == \ + spack.paths._get_user_cache_path() diff --git a/lib/spack/spack/test/conftest.py b/lib/spack/spack/test/conftest.py index 3d9acf4594..c946898076 100644 --- a/lib/spack/spack/test/conftest.py +++ b/lib/spack/spack/test/conftest.py @@ -13,6 +13,7 @@ import os import os.path import re import shutil +import stat import sys import tempfile import xml.etree.ElementTree @@ -297,6 +298,14 @@ def reset_compiler_cache(): spack.compilers._compiler_cache = {} +def onerror(func, path, error_info): + # Python on Windows is unable to remvove paths without + # write (IWUSR) permissions (such as those generated by Git on Windows) + # This method changes file permissions to allow removal by Python + os.chmod(path, stat.S_IWUSR) + func(path) + + @pytest.fixture(scope='function', autouse=True) def mock_stage(tmpdir_factory, monkeypatch, request): """Establish the temporary build_stage for the mock archive.""" @@ -320,7 +329,7 @@ def mock_stage(tmpdir_factory, monkeypatch, request): # Clean up the test stage directory if os.path.isdir(new_stage_path): - shutil.rmtree(new_stage_path) + shutil.rmtree(new_stage_path, onerror=onerror) else: # Must yield a path to avoid a TypeError on test teardown yield str(tmpdir_factory) @@ -343,7 +352,7 @@ def remove_whatever_it_is(path): elif os.path.islink(path): remove_linked_tree(path) else: - shutil.rmtree(path) + shutil.rmtree(path, onerror=onerror) @pytest.fixture @@ -902,7 +911,7 @@ class MockLayout(object): self.root = root def path_for_spec(self, spec): - return '/'.join([self.root, spec.name + '-' + spec.dag_hash()]) + return os.path.sep.join([self.root, spec.name + '-' + spec.dag_hash()]) def ensure_installed(self, spec): pass @@ -1048,10 +1057,7 @@ def mock_archive(request, tmpdir_factory): ['url', 'path', 'archive_file', 'expanded_archive_basedir']) archive_file = str(tmpdir.join(archive_name)) - if sys.platform == 'win32': - url = ('file:///' + archive_file) - else: - url = ('file://' + archive_file) + url = ('file://' + archive_file) # Return the url yield Archive( @@ -1540,11 +1546,14 @@ def mock_executable(tmpdir): output a custom string when run. """ import jinja2 + shebang = '#!/bin/bash\n' if not is_windows else '@ECHO OFF' def _factory(name, output, subdir=('bin',)): f = tmpdir.ensure(*subdir, dir=True).join(name) - t = jinja2.Template('#!/bin/bash\n{{ output }}\n') - f.write(t.render(output=output)) + if is_windows: + f += '.bat' + t = jinja2.Template('{{ shebang }}{{ output }}\n') + f.write(t.render(shebang=shebang, output=output)) f.chmod(0o755) return str(f) diff --git a/lib/spack/spack/test/database.py b/lib/spack/spack/test/database.py index a695b8d852..4278aeb4f0 100644 --- a/lib/spack/spack/test/database.py +++ b/lib/spack/spack/test/database.py @@ -65,7 +65,7 @@ def upstream_and_downstream_db(tmpdir_factory, gen_mock_layout): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Upstreams currently unsupported on Windows") @pytest.mark.usefixtures('config') def test_installed_upstream(upstream_and_downstream_db): upstream_write_db, upstream_db, upstream_layout,\ @@ -110,7 +110,7 @@ def test_installed_upstream(upstream_and_downstream_db): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Upstreams currently unsupported on Windows") @pytest.mark.usefixtures('config') def test_removed_upstream_dep(upstream_and_downstream_db): upstream_write_db, upstream_db, upstream_layout,\ @@ -143,7 +143,7 @@ def test_removed_upstream_dep(upstream_and_downstream_db): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Upstreams currently unsupported on Windows") @pytest.mark.usefixtures('config') def test_add_to_upstream_after_downstream(upstream_and_downstream_db): """An upstream DB can add a package after it is installed in the downstream @@ -182,7 +182,7 @@ def test_add_to_upstream_after_downstream(upstream_and_downstream_db): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Upstreams currently unsupported on Windows") @pytest.mark.usefixtures('config', 'temporary_store') def test_cannot_write_upstream(tmpdir_factory, gen_mock_layout): roots = [str(tmpdir_factory.mktemp(x)) for x in ['a', 'b']] @@ -209,7 +209,7 @@ def test_cannot_write_upstream(tmpdir_factory, gen_mock_layout): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Upstreams currently unsupported on Windows") @pytest.mark.usefixtures('config', 'temporary_store') def test_recursive_upstream_dbs(tmpdir_factory, gen_mock_layout): roots = [str(tmpdir_factory.mktemp(x)) for x in ['a', 'b', 'c']] @@ -687,8 +687,6 @@ def test_110_no_write_with_exception_on_install(database): # reload DB and make sure cmake was not written. with database.read_transaction(): - # import pdb; pdb.set_trace() - assert database.query('cmake', installed=any) == [] diff --git a/lib/spack/spack/test/directory_layout.py b/lib/spack/spack/test/directory_layout.py index 11bf7ed34a..7aa6a565fc 100644 --- a/lib/spack/spack/test/directory_layout.py +++ b/lib/spack/spack/test/directory_layout.py @@ -8,7 +8,6 @@ This test verifies that the Spack directory layout works properly. """ import os import os.path -import sys import pytest @@ -19,13 +18,12 @@ from spack.directory_layout import ( InvalidDirectoryLayoutParametersError, ) from spack.spec import Spec +from spack.util.path import path_to_os_path # number of packages to test (to reduce test time) max_packages = 10 -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_yaml_directory_layout_parameters(tmpdir, config): """This tests the various parameters that can be used to configure the install location """ @@ -81,8 +79,6 @@ def test_yaml_directory_layout_parameters(tmpdir, config): projections=projections_package7) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_read_and_write_spec(temporary_store, config, mock_packages): """This goes through each package in spack and creates a directory for it. It then ensures that the spec for the directory's @@ -108,7 +104,7 @@ def test_read_and_write_spec(temporary_store, config, mock_packages): layout.create_install_directory(spec) - install_dir = layout.path_for_spec(spec) + install_dir = path_to_os_path(layout.path_for_spec(spec))[0] spec_path = layout.spec_file_path(spec) # Ensure directory has been created in right place. @@ -208,8 +204,6 @@ def test_handle_unknown_package(temporary_store, config, mock_packages): assert spec.dag_hash() == spec_from_file.dag_hash() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_find(temporary_store, config, mock_packages): """Test that finding specs within an install layout works.""" layout = temporary_store.layout @@ -233,8 +227,6 @@ def test_find(temporary_store, config, mock_packages): assert found_specs[name].eq_dag(spec) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_yaml_directory_layout_build_path(tmpdir, config): """This tests build path method.""" spec = Spec('python') diff --git a/lib/spack/spack/test/environment_modifications.py b/lib/spack/spack/test/environment_modifications.py index 93e904a378..c76b08fd95 100644 --- a/lib/spack/spack/test/environment_modifications.py +++ b/lib/spack/spack/test/environment_modifications.py @@ -178,6 +178,7 @@ def test_filter_system_paths(miscellaneous_paths): assert filtered == expected +# TODO 27021 @pytest.mark.skipif(sys.platform == 'win32', reason="Not supported on Windows (yet)") def test_set_path(env): @@ -417,8 +418,6 @@ def test_sanitize_regex(env, blacklist, whitelist, expected, deleted): assert all(x not in after for x in deleted) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.regression('12085') @pytest.mark.parametrize('before,after,search_list', [ # Set environment variables @@ -428,8 +427,8 @@ def test_sanitize_regex(env, blacklist, whitelist, expected, deleted): # Append paths to an environment variable ({'FOO_PATH': '/a/path'}, {'FOO_PATH': '/a/path:/b/path'}, [environment.AppendPath('FOO_PATH', '/b/path')]), - ({}, {'FOO_PATH': '/a/path:/b/path'}, [ - environment.AppendPath('FOO_PATH', '/a/path:/b/path') + ({}, {'FOO_PATH': '/a/path' + os.sep + '/b/path'}, [ + environment.AppendPath('FOO_PATH', '/a/path' + os.sep + '/b/path') ]), ({'FOO_PATH': '/a/path:/b/path'}, {'FOO_PATH': '/b/path'}, [ environment.RemovePath('FOO_PATH', '/a/path') @@ -459,7 +458,7 @@ def test_from_environment_diff(before, after, search_list): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="LMod not supported on Windows") @pytest.mark.regression('15775') def test_blacklist_lmod_variables(): # Construct the list of environment modifications diff --git a/lib/spack/spack/test/git_fetch.py b/lib/spack/spack/test/git_fetch.py index af00651592..6e8993978c 100644 --- a/lib/spack/spack/test/git_fetch.py +++ b/lib/spack/spack/test/git_fetch.py @@ -19,6 +19,10 @@ from spack.stage import Stage from spack.util.executable import which from spack.version import ver +pytestmark = pytest.mark.skipif( + not which('git'), reason='requires git to be installed') + + _mock_transport_error = 'Mock HTTP transport error' @@ -71,7 +75,6 @@ def mock_bad_git(monkeypatch): def test_bad_git(tmpdir, mock_bad_git): """Trigger a SpackError when attempt a fetch with a bad git.""" testpath = str(tmpdir) - print(spack.config.get('config:locks')) with pytest.raises(spack.error.SpackError): fetcher = GitFetchStrategy(git='file:///not-a-real-git-repo') diff --git a/lib/spack/spack/test/install.py b/lib/spack/spack/test/install.py index 9465b5ec0e..00276b379c 100644 --- a/lib/spack/spack/test/install.py +++ b/lib/spack/spack/test/install.py @@ -5,7 +5,6 @@ import os import shutil -import sys import pytest @@ -32,8 +31,6 @@ def find_nothing(*args): 'Repo package access is disabled for test') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_and_uninstall(install_mockery, mock_fetch, monkeypatch): # Get a basic concrete spec for the trivial install package. spec = Spec('trivial-install-test-package') @@ -42,7 +39,6 @@ def test_install_and_uninstall(install_mockery, mock_fetch, monkeypatch): # Get the package pkg = spec.package - try: pkg.do_install() @@ -100,8 +96,6 @@ class MockStage(object): return getattr(self.wrapped_stage, attr) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_partial_install_delete_prefix_and_stage(install_mockery, mock_fetch): spec = Spec('canfail').concretized() pkg = spack.repo.get(spec) @@ -131,8 +125,6 @@ def test_partial_install_delete_prefix_and_stage(install_mockery, mock_fetch): pkg.remove_prefix = instance_rm_prefix -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.disable_clean_stage_check def test_failing_overwrite_install_should_keep_previous_installation( mock_fetch, install_mockery @@ -158,8 +150,6 @@ def test_failing_overwrite_install_should_keep_previous_installation( assert os.path.exists(spec.prefix) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_dont_add_patches_to_installed_package( install_mockery, mock_fetch, monkeypatch ): @@ -180,8 +170,6 @@ def test_dont_add_patches_to_installed_package( assert dependent['dependency-install'] == dependency -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installed_dependency_request_conflicts( install_mockery, mock_fetch, mutable_mock_repo): dependency = Spec('dependency-install') @@ -195,8 +183,6 @@ def test_installed_dependency_request_conflicts( dependent.concretize() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_dependency_symlinks_pkg( install_mockery, mock_fetch, mutable_mock_repo): """Test dependency flattening/symlinks mock package.""" @@ -210,8 +196,6 @@ def test_install_dependency_symlinks_pkg( assert os.path.isdir(dependency_dir) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_times( install_mockery, mock_fetch, mutable_mock_repo): """Test install times added.""" @@ -238,8 +222,6 @@ def test_install_times( assert abs(total - times['total']['seconds']) < 5 -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_flatten_deps( install_mockery, mock_fetch, mutable_mock_repo): """Explicitly test the flattening code for coverage purposes.""" @@ -289,8 +271,6 @@ def install_upstream(tmpdir_factory, gen_mock_layout, install_mockery): return _install_upstream -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installed_upstream_external(install_upstream, mock_fetch): """Check that when a dependency package is recorded as installed in an upstream database that it is not reinstalled. @@ -302,7 +282,8 @@ def test_installed_upstream_external(install_upstream, mock_fetch): new_dependency = dependent['externaltool'] assert new_dependency.external - assert new_dependency.prefix == '/path/to/external_tool' + assert new_dependency.prefix == \ + os.path.sep + os.path.join('path', 'to', 'external_tool') dependent.package.do_install() @@ -310,8 +291,6 @@ def test_installed_upstream_external(install_upstream, mock_fetch): assert os.path.exists(dependent.prefix) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installed_upstream(install_upstream, mock_fetch): """Check that when a dependency package is recorded as installed in an upstream database that it is not reinstalled. @@ -332,8 +311,6 @@ def test_installed_upstream(install_upstream, mock_fetch): assert os.path.exists(dependent.prefix) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.disable_clean_stage_check def test_partial_install_keep_prefix(install_mockery, mock_fetch, monkeypatch): spec = Spec('canfail').concretized() @@ -360,8 +337,6 @@ def test_partial_install_keep_prefix(install_mockery, mock_fetch, monkeypatch): assert not pkg.stage.test_destroyed -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_second_install_no_overwrite_first(install_mockery, mock_fetch, monkeypatch): spec = Spec('canfail').concretized() pkg = spack.repo.get(spec) @@ -376,8 +351,6 @@ def test_second_install_no_overwrite_first(install_mockery, mock_fetch, monkeypa pkg.do_install() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_prefix_collision_fails(config, mock_fetch, mock_packages, tmpdir): """ Test that different specs with coinciding install prefixes will fail @@ -395,16 +368,12 @@ def test_install_prefix_collision_fails(config, mock_fetch, mock_packages, tmpdi pkg_b.do_install() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Package ninja not found") def test_store(install_mockery, mock_fetch): spec = Spec('cmake-client').concretized() pkg = spec.package pkg.do_install() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.disable_clean_stage_check def test_failing_build(install_mockery, mock_fetch, capfd): spec = Spec('failing-build').concretized() @@ -419,8 +388,6 @@ class MockInstallError(spack.error.SpackError): pass -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_uninstall_by_spec_errors(mutable_database): """Test exceptional cases with the uninstall command.""" @@ -436,8 +403,6 @@ def test_uninstall_by_spec_errors(mutable_database): PackageBase.uninstall_by_spec(rec.spec) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.disable_clean_stage_check def test_nosource_pkg_install( install_mockery, mock_fetch, mock_packages, capfd): @@ -452,8 +417,6 @@ def test_nosource_pkg_install( assert "Missing a source id for nosource" in out[1] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_nosource_pkg_install_post_install( install_mockery, mock_fetch, mock_packages): """Test install phases with the nosource package with post-install.""" @@ -472,8 +435,6 @@ def test_nosource_pkg_install_post_install( assert os.path.isfile(post_install_txt) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_pkg_build_paths(install_mockery): # Get a basic concrete spec for the trivial install package. spec = Spec('trivial-install-test-package').concretized() @@ -507,8 +468,6 @@ def test_pkg_build_paths(install_mockery): shutil.rmtree(log_dir) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_pkg_install_paths(install_mockery): # Get a basic concrete spec for the trivial install package. spec = Spec('trivial-install-test-package').concretized() @@ -545,8 +504,6 @@ def test_pkg_install_paths(install_mockery): shutil.rmtree(log_dir) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_log_install_without_build_files(install_mockery): """Test the installer log function when no build files are present.""" # Get a basic concrete spec for the trivial install package. @@ -557,8 +514,6 @@ def test_log_install_without_build_files(install_mockery): spack.installer.log(spec.package) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_log_install_with_build_files(install_mockery, monkeypatch): """Test the installer's log function when have build files.""" config_log = 'config.log' diff --git a/lib/spack/spack/test/installer.py b/lib/spack/spack/test/installer.py index 053578f156..a7b0b1edd9 100644 --- a/lib/spack/spack/test/installer.py +++ b/lib/spack/spack/test/installer.py @@ -23,6 +23,8 @@ import spack.spec import spack.store import spack.util.lock as lk +is_windows = sys.platform == 'win32' + def _mock_repo(root, namespace): """Create an empty repository at the specified root @@ -119,8 +121,6 @@ def test_hms(sec, result): assert inst._hms(sec) == result -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_get_dependent_ids(install_mockery, mock_packages): # Concretize the parent package, which handle dependency too spec = spack.spec.Spec('a') @@ -154,8 +154,6 @@ def test_install_msg(monkeypatch): assert inst.install_msg(name, pid) == expected -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_from_cache_errors(install_mockery, capsys): """Test to ensure cover _install_from_cache errors.""" spec = spack.spec.Spec('trivial-install-test-package') @@ -176,8 +174,6 @@ def test_install_from_cache_errors(install_mockery, capsys): assert not spec.package.installed_from_binary_cache -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_from_cache_ok(install_mockery, monkeypatch): """Test to ensure cover _install_from_cache to the return.""" spec = spack.spec.Spec('trivial-install-test-package') @@ -188,8 +184,6 @@ def test_install_from_cache_ok(install_mockery, monkeypatch): assert inst._install_from_cache(spec.package, True, True, False) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_process_external_package_module(install_mockery, monkeypatch, capfd): """Test to simply cover the external module message path.""" spec = spack.spec.Spec('trivial-install-test-package') @@ -218,8 +212,6 @@ def test_process_binary_cache_tarball_none(install_mockery, monkeypatch, assert 'exists in binary cache but' in capfd.readouterr()[0] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_process_binary_cache_tarball_tar(install_mockery, monkeypatch, capfd): """Tests of _process_binary_cache_tarball with a tar file.""" def _spec(spec, preferred_mirrors=None): @@ -240,8 +232,6 @@ def test_process_binary_cache_tarball_tar(install_mockery, monkeypatch, capfd): assert 'from binary cache' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_try_install_from_binary_cache(install_mockery, mock_packages, monkeypatch): """Test return false when no match exists in the mirror""" @@ -251,8 +241,6 @@ def test_try_install_from_binary_cache(install_mockery, mock_packages, assert(not result) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installer_repr(install_mockery): const_arg = installer_args(['trivial-install-test-package'], {}) installer = create_installer(const_arg) @@ -263,8 +251,6 @@ def test_installer_repr(install_mockery): assert "failed=" in irep -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installer_str(install_mockery): const_arg = installer_args(['trivial-install-test-package'], {}) installer = create_installer(const_arg) @@ -298,8 +284,6 @@ def test_check_last_phase_error(install_mockery): assert pkg.last_phase in err -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installer_ensure_ready_errors(install_mockery): const_arg = installer_args(['trivial-install-test-package'], {}) installer = create_installer(const_arg) @@ -329,8 +313,6 @@ def test_installer_ensure_ready_errors(install_mockery): installer._ensure_install_ready(spec.package) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_ensure_locked_err(install_mockery, monkeypatch, tmpdir, capsys): """Test _ensure_locked when a non-lock exception is raised.""" mock_err_msg = 'Mock exception error' @@ -352,8 +334,6 @@ def test_ensure_locked_err(install_mockery, monkeypatch, tmpdir, capsys): assert mock_err_msg in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_ensure_locked_have(install_mockery, tmpdir, capsys): """Test _ensure_locked when already have lock.""" const_arg = installer_args(['trivial-install-test-package'], {}) @@ -390,8 +370,6 @@ def test_ensure_locked_have(install_mockery, tmpdir, capsys): assert installer._ensure_locked(lock_type, spec.package) == tpl -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('lock_type,reads,writes', [ ('read', 1, 0), ('write', 0, 1)]) @@ -409,8 +387,6 @@ def test_ensure_locked_new_lock( assert lock._writes == writes -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_ensure_locked_new_warn(install_mockery, monkeypatch, tmpdir, capsys): orig_pl = spack.database.Database.prefix_lock @@ -441,8 +417,6 @@ def test_package_id_err(install_mockery): inst.package_id(pkg) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_package_id_ok(install_mockery): spec = spack.spec.Spec('trivial-install-test-package') spec.concretize() @@ -461,8 +435,6 @@ def test_fake_install(install_mockery): assert os.path.isdir(pkg.prefix.lib) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_packages_needed_to_bootstrap_compiler_none(install_mockery): spec = spack.spec.Spec('trivial-install-test-package') spec.concretize() @@ -473,8 +445,6 @@ def test_packages_needed_to_bootstrap_compiler_none(install_mockery): assert not packages -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_packages_needed_to_bootstrap_compiler_packages(install_mockery, monkeypatch): spec = spack.spec.Spec('trivial-install-test-package') @@ -494,8 +464,6 @@ def test_packages_needed_to_bootstrap_compiler_packages(install_mockery, assert packages -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_dump_packages_deps_ok(install_mockery, tmpdir, mock_packages): """Test happy path for dump_packages with dependencies.""" @@ -508,8 +476,6 @@ def test_dump_packages_deps_ok(install_mockery, tmpdir, mock_packages): assert os.path.isfile(dest_pkg) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_dump_packages_deps_errs(install_mockery, tmpdir, monkeypatch, capsys): """Test error paths for dump_packages with dependencies.""" orig_bpp = spack.store.layout.build_packages_path @@ -538,7 +504,7 @@ def test_dump_packages_deps_errs(install_mockery, tmpdir, monkeypatch, capsys): # The call to install_tree will raise the exception since not mocking # creation of dependency package files within *install* directories. - with pytest.raises(IOError, match=path): + with pytest.raises(IOError, match=path if not is_windows else ''): inst.dump_packages(spec, path) # Now try the error path, which requires the mock directory structure @@ -631,8 +597,6 @@ def test_combine_phase_logs(tmpdir): assert "Output from %s\n" % log_file in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_check_deps_status_install_failure(install_mockery, monkeypatch): const_arg = installer_args(['a'], {}) installer = create_installer(const_arg) @@ -645,8 +609,6 @@ def test_check_deps_status_install_failure(install_mockery, monkeypatch): installer._check_deps_status(request) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_check_deps_status_write_locked(install_mockery, monkeypatch): const_arg = installer_args(['a'], {}) installer = create_installer(const_arg) @@ -659,8 +621,6 @@ def test_check_deps_status_write_locked(install_mockery, monkeypatch): installer._check_deps_status(request) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_check_deps_status_external(install_mockery, monkeypatch): const_arg = installer_args(['a'], {}) installer = create_installer(const_arg) @@ -672,8 +632,6 @@ def test_check_deps_status_external(install_mockery, monkeypatch): assert list(installer.installed)[0].startswith('b') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_check_deps_status_upstream(install_mockery, monkeypatch): const_arg = installer_args(['a'], {}) installer = create_installer(const_arg) @@ -685,8 +643,6 @@ def test_check_deps_status_upstream(install_mockery, monkeypatch): assert list(installer.installed)[0].startswith('b') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_add_bootstrap_compilers(install_mockery, monkeypatch): from collections import defaultdict @@ -709,8 +665,6 @@ def test_add_bootstrap_compilers(install_mockery, monkeypatch): assert task.compiler -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_prepare_for_install_on_installed(install_mockery, monkeypatch): """Test of _prepare_for_install's early return for installed task path.""" const_arg = installer_args(['dependent-install'], {}) @@ -725,8 +679,6 @@ def test_prepare_for_install_on_installed(install_mockery, monkeypatch): installer._prepare_for_install(task) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_installer_init_requests(install_mockery): """Test of installer initial requests.""" spec_name = 'dependent-install' @@ -740,8 +692,6 @@ def test_installer_init_requests(install_mockery): assert request.pkg.name == spec_name -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_task_use_cache(install_mockery, monkeypatch): const_arg = installer_args(['trivial-install-test-package'], {}) installer = create_installer(const_arg) @@ -753,8 +703,6 @@ def test_install_task_use_cache(install_mockery, monkeypatch): assert request.pkg_id in installer.installed -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_task_add_compiler(install_mockery, monkeypatch, capfd): config_msg = 'mock add_compilers_to_config' @@ -779,8 +727,6 @@ def test_install_task_add_compiler(install_mockery, monkeypatch, capfd): assert config_msg in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_release_lock_write_n_exception(install_mockery, tmpdir, capsys): """Test _release_lock for supposed write lock with exception.""" const_arg = installer_args(['trivial-install-test-package'], {}) @@ -798,8 +744,6 @@ def test_release_lock_write_n_exception(install_mockery, tmpdir, capsys): assert msg in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('installed', [True, False]) def test_push_task_skip_processed(install_mockery, installed): """Test to ensure skip re-queueing a processed package.""" @@ -819,8 +763,6 @@ def test_push_task_skip_processed(install_mockery, installed): assert len(list(installer.build_tasks)) == 0 -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_requeue_task(install_mockery, capfd): """Test to ensure cover _requeue_task.""" const_arg = installer_args(['a'], {}) @@ -845,8 +787,6 @@ def test_requeue_task(install_mockery, capfd): assert ' in progress by another process' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_cleanup_all_tasks(install_mockery, monkeypatch): """Test to ensure cover _cleanup_all_tasks.""" def _mktask(pkg): @@ -871,8 +811,6 @@ def test_cleanup_all_tasks(install_mockery, monkeypatch): assert len(installer.build_tasks) == 1 -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_setup_install_dir_grp(install_mockery, monkeypatch, capfd): """Test _setup_install_dir's group change.""" mock_group = 'mockgroup' @@ -893,6 +831,10 @@ def test_setup_install_dir_grp(install_mockery, monkeypatch, capfd): fs.touchp(spec.prefix) metadatadir = spack.store.layout.metadata_path(spec) + # Regex matching with Windows style paths typically fails + # so we skip the match check here + if is_windows: + metadatadir = None # Should fail with a "not a directory" error with pytest.raises(OSError, match=metadatadir): installer._setup_install_dir(spec.package) @@ -903,8 +845,6 @@ def test_setup_install_dir_grp(install_mockery, monkeypatch, capfd): assert expected_msg in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_cleanup_failed_err(install_mockery, tmpdir, monkeypatch, capsys): """Test _cleanup_failed exception path.""" msg = 'Fake release_write exception' @@ -927,8 +867,6 @@ def test_cleanup_failed_err(install_mockery, tmpdir, monkeypatch, capsys): assert msg in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_update_failed_no_dependent_task(install_mockery): """Test _update_failed with missing dependent build tasks.""" const_arg = installer_args(['dependent-install'], {}) @@ -941,8 +879,6 @@ def test_update_failed_no_dependent_task(install_mockery): assert installer.failed[task.pkg_id] is None -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_uninstalled_deps(install_mockery, monkeypatch, capsys): """Test install with uninstalled dependencies.""" const_arg = installer_args(['dependent-install'], {}) @@ -961,8 +897,6 @@ def test_install_uninstalled_deps(install_mockery, monkeypatch, capsys): assert 'Detected uninstalled dependencies for' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_failed(install_mockery, monkeypatch, capsys): """Test install with failed install.""" const_arg = installer_args(['b'], {}) @@ -979,8 +913,6 @@ def test_install_failed(install_mockery, monkeypatch, capsys): assert 'failed to install' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_failed_not_fast(install_mockery, monkeypatch, capsys): """Test install with failed install.""" const_arg = installer_args(['a'], {'fail_fast': False}) @@ -997,8 +929,6 @@ def test_install_failed_not_fast(install_mockery, monkeypatch, capsys): assert 'Skipping build of a' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_fail_on_interrupt(install_mockery, monkeypatch): """Test ctrl-c interrupted install.""" spec_name = 'a' @@ -1023,8 +953,6 @@ def test_install_fail_on_interrupt(install_mockery, monkeypatch): assert spec_name not in installer.installed -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_fail_single(install_mockery, monkeypatch): """Test expected results for failure of single package.""" spec_name = 'a' @@ -1052,8 +980,6 @@ def test_install_fail_single(install_mockery, monkeypatch): assert spec_name not in installer.installed -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_fail_multi(install_mockery, monkeypatch): """Test expected results for failure of multiple packages.""" spec_name = 'c' @@ -1081,8 +1007,6 @@ def test_install_fail_multi(install_mockery, monkeypatch): assert spec_name not in installer.installed -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_fail_fast_on_detect(install_mockery, monkeypatch, capsys): """Test fail_fast install when an install failure is detected.""" const_arg = installer_args(['b'], {'fail_fast': False}) @@ -1114,8 +1038,6 @@ def _test_install_fail_fast_on_except_patch(installer, **kwargs): raise RuntimeError('mock patch failure') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_fail_fast_on_except(install_mockery, monkeypatch, capsys): """Test fail_fast install when an install failure results from an error.""" const_arg = installer_args(['a'], {'fail_fast': True}) @@ -1138,8 +1060,6 @@ def test_install_fail_fast_on_except(install_mockery, monkeypatch, capsys): assert 'Skipping build of a' in out -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_lock_failures(install_mockery, monkeypatch, capfd): """Cover basic install lock failure handling in a single pass.""" def _requeued(installer, task): @@ -1163,8 +1083,6 @@ def test_install_lock_failures(install_mockery, monkeypatch, capfd): assert exp in ln -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_lock_installed_requeue(install_mockery, monkeypatch, capfd): """Cover basic install handling for installed package.""" const_arg = installer_args(['b'], {}) @@ -1200,8 +1118,6 @@ def test_install_lock_installed_requeue(install_mockery, monkeypatch, capfd): assert exp in ln -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_read_locked_requeue(install_mockery, monkeypatch, capfd): """Cover basic read lock handling for uninstalled package with requeue.""" orig_fn = inst.PackageInstaller._ensure_locked @@ -1240,8 +1156,6 @@ def test_install_read_locked_requeue(install_mockery, monkeypatch, capfd): assert exp in ln -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_install_skip_patch(install_mockery, mock_fetch): """Test the path skip_patch install path.""" spec_name = 'b' diff --git a/lib/spack/spack/test/link_paths.py b/lib/spack/spack/test/link_paths.py index c02d124a8c..cafb646322 100644 --- a/lib/spack/spack/test/link_paths.py +++ b/lib/spack/spack/test/link_paths.py @@ -3,6 +3,7 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) import os +import re import sys import pytest @@ -11,6 +12,9 @@ import spack.paths from spack.compiler import _parse_non_system_link_dirs is_windows = sys.platform == 'win32' +if is_windows: + drive_m = re.search(r'[A-Za-z]:', spack.paths.test_path) + drive = drive_m.group() if drive_m else None #: directory with sample compiler data datadir = os.path.join(spack.paths.test_path, 'data', 'compiler_verbose_output') @@ -27,7 +31,6 @@ def check_link_paths(filename, paths): with open(os.path.join(datadir, filename)) as file: output = file.read() detected_paths = _parse_non_system_link_dirs(output) - print(detected_paths) actual = detected_paths expected = paths @@ -44,9 +47,9 @@ def check_link_paths(filename, paths): def test_icc16_link_paths(): if is_windows: check_link_paths('icc-16.0.3.txt', [ - r'C:\usr\tce\packages\intel\intel-16.0.3\compilers_and_libraries_2016.3.210\linux\compiler\lib\intel64_lin', # noqa - r'C:\usr\tce\packages\gcc\gcc-4.9.3\lib64\gcc\x86_64-unknown-linux-gnu\4.9.3', # noqa - r'C:\usr\tce\packages\gcc\gcc-4.9.3\lib64']) + drive + r'\usr\tce\packages\intel\intel-16.0.3\compilers_and_libraries_2016.3.210\linux\compiler\lib\intel64_lin', # noqa + drive + r'\usr\tce\packages\gcc\gcc-4.9.3\lib64\gcc\x86_64-unknown-linux-gnu\4.9.3', # noqa + drive + r'\usr\tce\packages\gcc\gcc-4.9.3\lib64']) else: check_link_paths('icc-16.0.3.txt', [ '/usr/tce/packages/intel/intel-16.0.3/compilers_and_libraries_2016.3.210/linux/compiler/lib/intel64_lin', # noqa @@ -57,32 +60,26 @@ def test_icc16_link_paths(): def test_pgi_link_paths(): if is_windows: check_link_paths('pgcc-16.3.txt', [ - r'C:\usr\tce\packages\pgi\pgi-16.3\linux86-64\16.3\lib']) + drive + r'\usr\tce\packages\pgi\pgi-16.3\linux86-64\16.3\lib']) else: check_link_paths('pgcc-16.3.txt', [ '/usr/tce/packages/pgi/pgi-16.3/linux86-64/16.3/lib']) def test_gcc7_link_paths(): - if is_windows: - check_link_paths('gcc-7.3.1.txt', []) - else: - check_link_paths('gcc-7.3.1.txt', []) + check_link_paths('gcc-7.3.1.txt', []) def test_clang4_link_paths(): - if is_windows: - check_link_paths('clang-4.0.1.txt', []) - else: - check_link_paths('clang-4.0.1.txt', []) + check_link_paths('clang-4.0.1.txt', []) def test_xl_link_paths(): if is_windows: check_link_paths('xl-13.1.5.txt', [ - r'C:\opt\ibm\xlsmp\4.1.5\lib', - r'C:\opt\ibm\xlmass\8.1.5\lib', - r'C:\opt\ibm\xlC\13.1.5\lib']) + drive + r'\opt\ibm\xlsmp\4.1.5\lib', + drive + r'\opt\ibm\xlmass\8.1.5\lib', + drive + r'\opt\ibm\xlC\13.1.5\lib']) else: check_link_paths('xl-13.1.5.txt', [ '/opt/ibm/xlsmp/4.1.5/lib', @@ -93,22 +90,23 @@ def test_xl_link_paths(): def test_cce_link_paths(): if is_windows: check_link_paths('cce-8.6.5.txt', [ - r'C:\opt\gcc\6.1.0\snos\lib64', - r'C:\opt\cray\dmapp\default\lib64', - r'C:\opt\cray\pe\mpt\7.7.0\gni\mpich-cray\8.6\lib', - r'C:\opt\cray\pe\libsci\17.12.1\CRAY\8.6\x86_64\lib', - r'C:\opt\cray\rca\2.2.16-6.0.5.0_15.34__g5e09e6d.ari\lib64', - r'C:\opt\cray\pe\pmi\5.0.13\lib64', - r'C:\opt\cray\xpmem\2.2.4-6.0.5.0_4.8__g35d5e73.ari\lib64', - r'C:\opt\cray\dmapp\7.1.1-6.0.5.0_49.8__g1125556.ari\lib64', - r'C:\opt\cray\ugni\6.0.14-6.0.5.0_16.9__g19583bb.ari\lib64', - r'C:\opt\cray\udreg\2.3.2-6.0.5.0_13.12__ga14955a.ari\lib64', - r'C:\opt\cray\alps\6.5.28-6.0.5.0_18.6__g13a91b6.ari\lib64', - r'C:\opt\cray\pe\atp\2.1.1\libApp', - r'C:\opt\cray\pe\cce\8.6.5\cce\x86_64\lib', - r'C:\opt\cray\wlm_detect\1.3.2-6.0.5.0_3.1__g388ccd5.ari\lib64', - r'C:\opt\gcc\6.1.0\snos\lib\gcc\x86_64-suse-linux\6.1.0', - r'C:\opt\cray\pe\cce\8.6.5\binutils\x86_64\x86_64-unknown-linux-gnu\lib']) + drive + r'\opt\gcc\6.1.0\snos\lib64', + drive + r'\opt\cray\dmapp\default\lib64', + drive + r'\opt\cray\pe\mpt\7.7.0\gni\mpich-cray\8.6\lib', + drive + r'\opt\cray\pe\libsci\17.12.1\CRAY\8.6\x86_64\lib', + drive + r'\opt\cray\rca\2.2.16-6.0.5.0_15.34__g5e09e6d.ari\lib64', + drive + r'\opt\cray\pe\pmi\5.0.13\lib64', + drive + r'\opt\cray\xpmem\2.2.4-6.0.5.0_4.8__g35d5e73.ari\lib64', + drive + r'\opt\cray\dmapp\7.1.1-6.0.5.0_49.8__g1125556.ari\lib64', + drive + r'\opt\cray\ugni\6.0.14-6.0.5.0_16.9__g19583bb.ari\lib64', + drive + r'\opt\cray\udreg\2.3.2-6.0.5.0_13.12__ga14955a.ari\lib64', + drive + r'\opt\cray\alps\6.5.28-6.0.5.0_18.6__g13a91b6.ari\lib64', + drive + r'\opt\cray\pe\atp\2.1.1\libApp', + drive + r'\opt\cray\pe\cce\8.6.5\cce\x86_64\lib', + drive + r'\opt\cray\wlm_detect\1.3.2-6.0.5.0_3.1__g388ccd5.ari\lib64', + drive + r'\opt\gcc\6.1.0\snos\lib\gcc\x86_64-suse-linux\6.1.0', + drive + + r'\opt\cray\pe\cce\8.6.5\binutils\x86_64\x86_64-unknown-linux-gnu\lib']) else: check_link_paths('cce-8.6.5.txt', [ '/opt/gcc/6.1.0/snos/lib64', @@ -132,7 +130,7 @@ def test_cce_link_paths(): def test_clang_apple_ld_link_paths(): if is_windows: check_link_paths('clang-9.0.0-apple-ld.txt', [ - r'C:\Applications\Xcode.app\Contents\Developer\Platforms\MacOSX.platform\Developer\SDKs\MacOSX10.13.sdk\usr\lib']) # noqa + drive + r'\Applications\Xcode.app\Contents\Developer\Platforms\MacOSX.platform\Developer\SDKs\MacOSX10.13.sdk\usr\lib']) # noqa else: check_link_paths('clang-9.0.0-apple-ld.txt', [ '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/lib']) # noqa @@ -145,9 +143,9 @@ def test_nag_mixed_gcc_gnu_ld_link_paths(): # '/path/to/gcc/bin/g++ -Wl,-v ./main.c'. if is_windows: check_link_paths('collect2-6.3.0-gnu-ld.txt', [ - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib\gcc\x86_64-pc-linux-gnu\6.5.0', # noqa - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib64', # noqa - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib']) # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib\gcc\x86_64-pc-linux-gnu\6.5.0', # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib64', # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib']) # noqa else: check_link_paths('collect2-6.3.0-gnu-ld.txt', [ '/scratch/local1/spack/opt/spack/gcc-6.3.0-haswell/gcc-6.5.0-4sdjgrs/lib/gcc/x86_64-pc-linux-gnu/6.5.0', # noqa @@ -162,9 +160,9 @@ def test_nag_link_paths(): # 'nagfor -Wc=/path/to/gcc/bin/gcc -Wl,-v ./main.c'. if is_windows: check_link_paths('nag-6.2-gcc-6.5.0.txt', [ - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib\gcc\x86_64-pc-linux-gnu\6.5.0', # noqa - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib64', # noqa - r'C:\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib']) # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib\gcc\x86_64-pc-linux-gnu\6.5.0', # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib64', # noqa + drive + r'\scratch\local1\spack\opt\spack\gcc-6.3.0-haswell\gcc-6.5.0-4sdjgrs\lib']) # noqa else: check_link_paths('nag-6.2-gcc-6.5.0.txt', [ '/scratch/local1/spack/opt/spack/gcc-6.3.0-haswell/gcc-6.5.0-4sdjgrs/lib/gcc/x86_64-pc-linux-gnu/6.5.0', # noqa @@ -175,8 +173,8 @@ def test_nag_link_paths(): def test_obscure_parsing_rules(): if is_windows: check_link_paths('obscure-parsing-rules.txt', [ - r'C:\first\path', - r'C:\third\path']) + drive + r'\first\path', + drive + r'\third\path']) else: check_link_paths('obscure-parsing-rules.txt', [ '/first/path', diff --git a/lib/spack/spack/test/llnl/util/filesystem.py b/lib/spack/spack/test/llnl/util/filesystem.py index 463ca1da5a..2bd6994754 100644 --- a/lib/spack/spack/test/llnl/util/filesystem.py +++ b/lib/spack/spack/test/llnl/util/filesystem.py @@ -176,21 +176,15 @@ class TestCopyTree: fs.copy_tree('source', 'dest', symlinks=True) assert os.path.exists('dest/2') - if sys.platform != "win32": - # TODO: islink will return false for junctions - assert islink('dest/2') + assert islink('dest/2') assert os.path.exists('dest/a/b2') - if sys.platform != "win32": - # TODO: Not supported for junctions ? - with fs.working_dir('dest/a'): - assert os.path.exists(os.readlink('b2')) + with fs.working_dir('dest/a'): + assert os.path.exists(os.readlink('b2')) - if sys.platform != "win32": - # TODO: Not supported on Windows ? - assert (os.path.realpath('dest/f/2') == - os.path.abspath('dest/a/b/2')) - assert os.path.realpath('dest/2') == os.path.abspath('dest/1') + assert (os.path.realpath('dest/f/2') == + os.path.abspath('dest/a/b/2')) + assert os.path.realpath('dest/2') == os.path.abspath('dest/1') def test_symlinks_true_ignore(self, stage): """Test copying when specifying relative paths that should be ignored @@ -387,7 +381,6 @@ def test_recursive_search_of_headers_from_prefix( if sys.platform == "win32": - # TODO: Test \\s dir_list = [ (['C:/pfx/include/foo.h', 'C:/pfx/include/subdir/foo.h'], ['C:/pfx/include']), (['C:/pfx/include/foo.h', 'C:/pfx/subdir/foo.h'], diff --git a/lib/spack/spack/test/llnl/util/lock.py b/lib/spack/spack/test/llnl/util/lock.py index 211d822a61..da8f77b2c3 100644 --- a/lib/spack/spack/test/llnl/util/lock.py +++ b/lib/spack/spack/test/llnl/util/lock.py @@ -628,6 +628,7 @@ def test_read_lock_read_only_dir_writable_lockfile(lock_dir, lock_path): pass +@pytest.mark.skipif(False if is_windows else getuid() == 0, reason='user is root') def test_read_lock_no_lockfile(lock_dir, lock_path): """read-only directory, no lockfile (so can't create).""" with read_only(lock_dir): @@ -689,13 +690,11 @@ def test_upgrade_read_to_write_fails_with_readonly_file(private_lock_path): lock = lk.Lock(private_lock_path) assert lock._reads == 0 assert lock._writes == 0 - assert lock._current_lock is None lock.acquire_read() assert lock._reads == 1 assert lock._writes == 0 assert lock._file.mode == 'r' - assert lock._current_lock == lock.LOCK_SH # upgrade to write here with pytest.raises(lk.LockROFileError): @@ -1358,6 +1357,7 @@ def test_poll_lock_exception(tmpdir, monkeypatch, err_num, err_msg): lock = lk.Lock(lockfile) touch(lockfile) + monkeypatch.setattr(fcntl, 'lockf', _lockf) if err_num in [errno.EAGAIN, errno.EACCES]: diff --git a/lib/spack/spack/test/llnl/util/tty/log.py b/lib/spack/spack/test/llnl/util/tty/log.py index fd8c7d30da..2491a5dbe3 100644 --- a/lib/spack/spack/test/llnl/util/tty/log.py +++ b/lib/spack/spack/test/llnl/util/tty/log.py @@ -18,8 +18,8 @@ if TYPE_CHECKING: import pytest -import llnl.util.tty.log as log import llnl.util.lang as lang +import llnl.util.tty.log as log import llnl.util.tty.pty as pty from spack.util.executable import which diff --git a/lib/spack/spack/test/main.py b/lib/spack/spack/test/main.py index 1bbe594666..9917fac6f5 100644 --- a/lib/spack/spack/test/main.py +++ b/lib/spack/spack/test/main.py @@ -15,7 +15,7 @@ from spack.main import get_version, main pytestmark = pytest.mark.skipif( sys.platform == 'win32', - reason="Test functionality support but failing on Win") + reason="Test functionality supported but tests are failing on Win") def test_get_version_no_match_git(tmpdir, working_env): diff --git a/lib/spack/spack/test/make_executable.py b/lib/spack/spack/test/make_executable.py index a814601176..9fcf4cc8c4 100644 --- a/lib/spack/spack/test/make_executable.py +++ b/lib/spack/spack/test/make_executable.py @@ -20,7 +20,8 @@ from spack.build_environment import MakeExecutable from spack.util.environment import path_put_first pytestmark = pytest.mark.skipif(sys.platform == "win32", - reason="does not run on windows") + reason="MakeExecutable \ + not supported on Windows") class MakeExecutableTest(unittest.TestCase): diff --git a/lib/spack/spack/test/module_parsing.py b/lib/spack/spack/test/module_parsing.py index d20f6a2b95..2a19d39033 100644 --- a/lib/spack/spack/test/module_parsing.py +++ b/lib/spack/spack/test/module_parsing.py @@ -17,6 +17,9 @@ from spack.util.module_cmd import ( path_from_modules, ) +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Tests fail on Windows") + test_module_lines = ['prepend-path LD_LIBRARY_PATH /path/to/lib', 'setenv MOD_DIR /path/to', 'setenv LDFLAGS -Wl,-rpath/path/to/lib', @@ -24,8 +27,6 @@ test_module_lines = ['prepend-path LD_LIBRARY_PATH /path/to/lib', 'prepend-path PATH /path/to/bin'] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_module_function_change_env(tmpdir, working_env): src_file = str(tmpdir.join('src_me')) with open(src_file, 'w') as f: @@ -38,8 +39,6 @@ def test_module_function_change_env(tmpdir, working_env): assert os.environ['NOT_AFFECTED'] == "NOT_AFFECTED" -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_module_function_no_change(tmpdir): src_file = str(tmpdir.join('src_me')) with open(src_file, 'w') as f: @@ -128,6 +127,7 @@ def test_get_argument_from_module_line(): get_path_args_from_module_line(bl) +# lmod is entirely unsupported on Windows def test_lmod_quote_parsing(): lines = ['setenv("SOME_PARTICULAR_DIR","-L/opt/cray/pe/mpich/8.1.4/gtl/lib")'] result = get_path_from_module_contents(lines, 'some-module') diff --git a/lib/spack/spack/test/optional_deps.py b/lib/spack/spack/test/optional_deps.py index 313903d272..84c3f2df43 100644 --- a/lib/spack/spack/test/optional_deps.py +++ b/lib/spack/spack/test/optional_deps.py @@ -3,8 +3,6 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) -import sys - import pytest from spack.spec import Spec @@ -98,8 +96,6 @@ def test_normalize(spec_and_expected, config, mock_packages): assert spec.eq_dag(expected, deptypes=False) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_default_variant(config, mock_packages): spec = Spec('optional-dep-test-3') spec.concretize() diff --git a/lib/spack/spack/test/packages.py b/lib/spack/spack/test/packages.py index be8243fd6f..e403d85899 100644 --- a/lib/spack/spack/test/packages.py +++ b/lib/spack/spack/test/packages.py @@ -4,7 +4,6 @@ # SPDX-License-Identifier: (Apache-2.0 OR MIT) import os -import sys import pytest @@ -64,8 +63,6 @@ class TestPackage(object): import spack.pkg.builtin.mock.mpich as mp # noqa from spack.pkg.builtin import mock # noqa - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_inheritance_of_diretives(self): p = spack.repo.get('simple-inheritance') @@ -91,16 +88,12 @@ class TestPackage(object): assert '~openblas' in s assert 'mpi' in s - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.regression('11844') def test_inheritance_of_patches(self): s = Spec('patch-inheritance') # Will error if inheritor package cannot find inherited patch files s.concretize() - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_dependency_extensions(self): s = Spec('extension2') s.concretize() @@ -125,8 +118,6 @@ class TestPackage(object): from spack.pkg.builtin import mock # noqa -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.regression('2737') def test_urls_for_versions(mock_packages, config): """Version directive without a 'url' argument should use default url.""" @@ -151,8 +142,6 @@ def test_url_for_version_with_no_urls(mock_packages, config): pkg.url_for_version('1.1') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_url_for_version_with_only_overrides(mock_packages, config): spec = Spec('url-only-override') spec.concretize() @@ -171,8 +160,6 @@ def test_url_for_version_with_only_overrides(mock_packages, config): assert pkg.url_for_version('0.7.0') == 'http://c.example.com/url_override-0.7.0.tar.gz' -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_url_for_version_with_only_overrides_with_gaps(mock_packages, config): spec = Spec('url-only-override-with-gaps') spec.concretize() @@ -340,8 +327,6 @@ def test_git_url_top_level_conflicts(mock_packages, config): spack.fetch_strategy.for_package_version(pkg, '1.3') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_rpath_args(mutable_database): """Test a package's rpath_args property.""" diff --git a/lib/spack/spack/test/packaging.py b/lib/spack/spack/test/packaging.py index b23df6e30d..ff68418ac4 100644 --- a/lib/spack/spack/test/packaging.py +++ b/lib/spack/spack/test/packaging.py @@ -40,6 +40,9 @@ from spack.relocate import ( ) from spack.spec import Spec +pytestmark = pytest.mark.skipif(sys.platform == "win32", + reason="does not run on windows") + def fake_fetchify(url, pkg): """Fake the URL for a package so it downloads from a file.""" @@ -48,8 +51,6 @@ def fake_fetchify(url, pkg): pkg.fetcher = fetcher -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('install_mockery', 'mock_gnupghome') def test_buildcache(mock_archive, tmpdir): # tweak patchelf to only do a download @@ -192,8 +193,6 @@ echo $PATH""" bindist._cached_specs = set() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('install_mockery') def test_relocate_text(tmpdir): spec = Spec('trivial-install-test-package') @@ -217,8 +216,6 @@ def test_relocate_text(tmpdir): bindist._cached_specs = set() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_relocate_links(tmpdir): with tmpdir.as_cwd(): old_layout_root = os.path.join( @@ -260,8 +257,6 @@ def test_needs_relocation(): assert needs_binary_relocation('application', 'x-mach-binary') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_replace_paths(tmpdir): with tmpdir.as_cwd(): suffix = 'dylib' if platform.system().lower() == 'darwin' else 'so' @@ -471,8 +466,6 @@ def test_replace_paths(tmpdir): } -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_macho_make_paths(): out = macho_make_paths_relative('/Users/Shared/spack/pkgC/lib/libC.dylib', '/Users/Shared/spack', diff --git a/lib/spack/spack/test/patch.py b/lib/spack/spack/test/patch.py index 1eaec4e7b9..0d88b93c23 100644 --- a/lib/spack/spack/test/patch.py +++ b/lib/spack/spack/test/patch.py @@ -19,20 +19,26 @@ import spack.util.compression from spack.spec import Spec from spack.stage import Stage from spack.util.executable import Executable +from spack.util.path import is_windows # various sha256 sums (using variables for legibility) +# many file based shas will differ between Windows and other platforms +# due to the use of carriage returns ('\r\n') in Windows line endings # files with contents 'foo', 'bar', and 'baz' -foo_sha256 = 'b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b878ae4944c' -bar_sha256 = '7d865e959b2466918c9863afca942d0fb89d7c9ac0c99bafc3749504ded97730' -baz_sha256 = 'bf07a7fbb825fc0aae7bf4a1177b2b31fcf8a3feeaf7092761e18c859ee52a9c' -biz_sha256 = 'a69b288d7393261e613c276c6d38a01461028291f6e381623acc58139d01f54d' +foo_sha256 = 'b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b878ae4944c' if not is_windows else 'bf874c7dd3a83cf370fdc17e496e341de06cd596b5c66dbf3c9bb7f6c139e3ee' +bar_sha256 = '7d865e959b2466918c9863afca942d0fb89d7c9ac0c99bafc3749504ded97730' if not is_windows else '556ddc69a75d0be0ecafc82cd4657666c8063f13d762282059c39ff5dbf18116' +baz_sha256 = 'bf07a7fbb825fc0aae7bf4a1177b2b31fcf8a3feeaf7092761e18c859ee52a9c' if not is_windows else 'd30392e66c636a063769cbb1db08cd3455a424650d4494db6379d73ea799582b' +biz_sha256 = 'a69b288d7393261e613c276c6d38a01461028291f6e381623acc58139d01f54d' if not is_windows else '2f2b087a8f84834fd03d4d1d5b43584011e869e4657504ef3f8b0a672a5c222e' # url patches +# url shas are the same on Windows url1_sha256 = 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234' url2_sha256 = '1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd' url2_archive_sha256 = 'abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd' +platform_url_sha = '252c0af58be3d90e5dc5e0d16658434c9efa5d20a5df6c10bf72c2d77f780866' if not is_windows else 'ecf44a8244a486e9ef5f72c6cb622f99718dcd790707ac91af0b8c9a4ab7a2bb' + @pytest.fixture() def mock_patch_stage(tmpdir_factory, monkeypatch): @@ -46,7 +52,7 @@ data_path = os.path.join(spack.paths.test_path, 'data', 'patch') @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Line ending conflict on Windows") @pytest.mark.parametrize('filename, sha256, archive_sha256', [ # compressed patch -- needs sha256 and archive_256 (os.path.join(data_path, 'foo.tgz'), @@ -54,7 +60,7 @@ data_path = os.path.join(spack.paths.test_path, 'data', 'patch') '4e8092a161ec6c3a1b5253176fcf33ce7ba23ee2ff27c75dbced589dabacd06e'), # uncompressed patch -- needs only sha256 (os.path.join(data_path, 'foo.patch'), - '252c0af58be3d90e5dc5e0d16658434c9efa5d20a5df6c10bf72c2d77f780866', + platform_url_sha, None) ]) def test_url_patch(mock_patch_stage, filename, sha256, archive_sha256): @@ -92,8 +98,6 @@ third line assert filecmp.cmp('foo.txt', 'foo-expected.txt') -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_patch_in_spec(mock_packages, config): """Test whether patches in a package appear in the spec.""" spec = Spec('patch') @@ -112,8 +116,6 @@ def test_patch_in_spec(mock_packages, config): tuple(spec.variants['patches']._patches_in_order_of_appearance)) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_patch_mixed_versions_subset_constraint(mock_packages, config): """If we have a package with mixed x.y and x.y.z versions, make sure that a patch applied to a version range of x.y.z versions is not applied to @@ -128,15 +130,17 @@ def test_patch_mixed_versions_subset_constraint(mock_packages, config): assert biz_sha256 not in spec2.variants['patches'].value -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_patch_order(mock_packages, config): spec = Spec('dep-diamond-patch-top') spec.concretize() - mid2_sha256 = 'mid21234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234' - mid1_sha256 = '0b62284961dab49887e31319843431ee5b037382ac02c4fe436955abef11f094' - top_sha256 = 'f7de2947c64cb6435e15fb2bef359d1ed5f6356b2aebb7b20535e3772904e6db' + mid2_sha256 = 'mid21234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234' \ + if not is_windows \ + else 'mid21234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234' + mid1_sha256 = '0b62284961dab49887e31319843431ee5b037382ac02c4fe436955abef11f094' \ + if not is_windows else 'aeb16c4dec1087e39f2330542d59d9b456dd26d791338ae6d80b6ffd10c89dfa' + top_sha256 = 'f7de2947c64cb6435e15fb2bef359d1ed5f6356b2aebb7b20535e3772904e6db' \ + if not is_windows else 'ff34cb21271d16dbf928374f610bb5dd593d293d311036ddae86c4846ff79070' dep = spec['patch'] patch_order = dep.variants['patches']._patches_in_order_of_appearance @@ -178,7 +182,7 @@ def test_nested_directives(mock_packages): @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") + reason="Test requires Autotools") def test_patched_dependency( mock_packages, config, install_mockery, mock_fetch): """Test whether patched dependencies work.""" @@ -187,7 +191,9 @@ def test_patched_dependency( assert 'patches' in list(spec['libelf'].variants.keys()) # make sure the patch makes it into the dependency spec - assert (('c45c1564f70def3fc1a6e22139f62cb21cd190cc3a7dbe6f4120fa59ce33dcb8',) == + t_sha = 'c45c1564f70def3fc1a6e22139f62cb21cd190cc3a7dbe6f4120fa59ce33dcb8' \ + if not is_windows else '3c5b65abcd6a3b2c714dbf7c31ff65fe3748a1adc371f030c283007ca5534f11' + assert ((t_sha,) == spec['libelf'].variants['patches'].value) # make sure the patch in the dependent's directory is applied to the @@ -206,8 +212,6 @@ def test_patched_dependency( assert 'Patched!' in mf.read() -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_multiple_patched_dependencies(mock_packages, config): """Test whether multiple patched dependencies work.""" spec = Spec('patch-several-dependencies') @@ -226,8 +230,6 @@ def test_multiple_patched_dependencies(mock_packages, config): (url2_sha256, url1_sha256) == spec['fake'].variants['patches'].value) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_conditional_patched_dependencies(mock_packages, config): """Test whether conditional patched dependencies work.""" spec = Spec('patch-several-dependencies @1.0') @@ -309,8 +311,6 @@ def check_multi_dependency_patch_specs( assert url2_patch.archive_sha256 == url2_archive_sha256 -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_conditional_patched_deps_with_conditions(mock_packages, config): """Test whether conditional patched dependencies with conditions work.""" spec = Spec('patch-several-dependencies @1.0 ^libdwarf@20111030') @@ -326,8 +326,6 @@ def test_conditional_patched_deps_with_conditions(mock_packages, config): spec.package.package_dir) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_write_and_read_sub_dags_with_patched_deps(mock_packages, config): """Test whether patched dependencies are still correct after writing and reading a sub-DAG of a concretized Spec. diff --git a/lib/spack/spack/test/permissions.py b/lib/spack/spack/test/permissions.py index 01787922ae..e2667b9b56 100644 --- a/lib/spack/spack/test/permissions.py +++ b/lib/spack/spack/test/permissions.py @@ -13,9 +13,10 @@ import llnl.util.filesystem as fs from spack.util.file_permissions import InvalidPermissionsError, set_permissions +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="chmod unsupported on Windows") + -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_chmod_real_entries_ignores_suid_sgid(tmpdir): path = str(tmpdir.join('file').ensure()) mode = stat.S_ISUID | stat.S_ISGID | stat.S_ISVTX @@ -28,8 +29,6 @@ def test_chmod_real_entries_ignores_suid_sgid(tmpdir): assert os.stat(path).st_mode == mode | perms & ~stat.S_IXUSR -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_chmod_rejects_group_writable_suid(tmpdir): path = str(tmpdir.join('file').ensure()) mode = stat.S_ISUID @@ -40,8 +39,6 @@ def test_chmod_rejects_group_writable_suid(tmpdir): set_permissions(path, perms) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_chmod_rejects_world_writable_suid(tmpdir): path = str(tmpdir.join('file').ensure()) mode = stat.S_ISUID @@ -52,8 +49,6 @@ def test_chmod_rejects_world_writable_suid(tmpdir): set_permissions(path, perms) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_chmod_rejects_world_writable_sgid(tmpdir): path = str(tmpdir.join('file').ensure()) mode = stat.S_ISGID diff --git a/lib/spack/spack/test/relocate.py b/lib/spack/spack/test/relocate.py index ac490b5fb2..b5c0151420 100644 --- a/lib/spack/spack/test/relocate.py +++ b/lib/spack/spack/test/relocate.py @@ -21,6 +21,9 @@ import spack.store import spack.tengine import spack.util.executable +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Tests fail on Windows") + def skip_unless_linux(f): return pytest.mark.skipif( @@ -225,8 +228,6 @@ def test_file_is_relocatable_errors(tmpdir): assert 'is not an absolute path' in str(exc_info.value) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('patchelf_behavior,expected', [ ('echo ', []), ('echo /opt/foo/lib:/opt/foo/lib64', ['/opt/foo/lib', '/opt/foo/lib64']), @@ -269,8 +270,6 @@ def test_normalize_relative_paths(start_path, relative_paths, expected): assert normalized == expected -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_set_elf_rpaths(mock_patchelf): # Try to relocate a mock version of patchelf and check # the call made to patchelf itself diff --git a/lib/spack/spack/test/sbang.py b/lib/spack/spack/test/sbang.py index ce64d0669b..2a4189e7f8 100644 --- a/lib/spack/spack/test/sbang.py +++ b/lib/spack/spack/test/sbang.py @@ -60,7 +60,7 @@ last_line = "last!\n" @pytest.fixture # type: ignore[no-redef] def sbang_line(): - yield '#!/bin/sh {0}{1}bin{1}sbang\n'.format(spack.store.layout.root, os.sep) + yield '#!/bin/sh %s/bin/sbang\n' % spack.store.layout.root class ScriptDirectory(object): diff --git a/lib/spack/spack/test/spec_dag.py b/lib/spack/spack/test/spec_dag.py index 991adc5fc3..046ff7aad2 100644 --- a/lib/spack/spack/test/spec_dag.py +++ b/lib/spack/spack/test/spec_dag.py @@ -5,8 +5,6 @@ """ These tests check Spec DAG operations using dummy packages. """ -import sys - import pytest import spack.error @@ -16,9 +14,6 @@ from spack.dependency import Dependency, all_deptypes, canonical_deptype from spack.spec import Spec from spack.util.mock_package import MockPackageMultiRepo -pytestmark = pytest.mark.skipif(sys.platform == "win32", - reason="does not run on windows") - def check_links(spec_to_check): for spec in spec_to_check.traverse(): diff --git a/lib/spack/spack/test/spec_semantics.py b/lib/spack/spack/test/spec_semantics.py index 0c948c046c..fe8e07a54f 100644 --- a/lib/spack/spack/test/spec_semantics.py +++ b/lib/spack/spack/test/spec_semantics.py @@ -314,8 +314,6 @@ class TestSpecSematics(object): check_satisfies('multivalue-variant foo="bar,baz"', 'foo="bar"') - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_satisfies_single_valued_variant(self): """Tests that the case reported in https://github.com/spack/spack/pull/2386#issuecomment-282147639 @@ -339,8 +337,6 @@ class TestSpecSematics(object): # Check that conditional dependencies are treated correctly assert '^b' in a - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_unsatisfied_single_valued_variant(self): a = Spec('a foobar=baz') a.concretize() @@ -350,15 +346,11 @@ class TestSpecSematics(object): mv.concretize() assert 'a@1.0' not in mv - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_indirect_unsatisfied_single_valued_variant(self): spec = Spec('singlevalue-variant-dependent') spec.concretize() assert 'a@1.0' not in spec - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_unsatisfiable_multi_value_variant(self): # Semantics for a multi-valued variant is different @@ -491,8 +483,6 @@ class TestSpecSematics(object): # 'mpich' is concrete: check_unsatisfiable('mpich', 'mpich cppflags="-O3"', True) - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_copy_satisfies_transitive(self): spec = Spec('dttop') spec.concretize() @@ -506,8 +496,6 @@ class TestSpecSematics(object): check_unsatisfiable( 'mpich cppflags="-O3"', 'mpich cppflags="-O2"') - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_satisfies_virtual(self): # Don't use check_satisfies: it checks constrain() too, and # you can't constrain a non-virtual by a virtual. @@ -515,8 +503,6 @@ class TestSpecSematics(object): assert Spec('mpich2').satisfies(Spec('mpi')) assert Spec('zmpi').satisfies(Spec('mpi')) - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_satisfies_virtual_dep_with_virtual_constraint(self): """Ensure we can satisfy virtual constraints when there are multiple vdep providers in the specs.""" @@ -533,8 +519,6 @@ class TestSpecSematics(object): 'netlib-lapack ^netlib-blas' ) - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_satisfies_same_spec_with_different_hash(self): """Ensure that concrete specs are matched *exactly* by hash.""" s1 = Spec('mpileaks').concretized() @@ -580,8 +564,6 @@ class TestSpecSematics(object): assert 'libelf' in s assert 'mpi' in s - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.usefixtures('config') def test_virtual_index(self): s = Spec('callpath') @@ -776,8 +758,6 @@ class TestSpecSematics(object): with pytest.raises(ValueError): Spec('libelf foo') - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_spec_formatting(self): spec = Spec("multivalue-variant cflags=-O2") spec.concretize() @@ -850,8 +830,6 @@ class TestSpecSematics(object): actual = spec.format(named_str) assert expected == actual - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_spec_formatting_escapes(self): spec = Spec('multivalue-variant cflags=-O2') spec.concretize() @@ -884,8 +862,6 @@ class TestSpecSematics(object): with pytest.raises(SpecFormatStringError): spec.format(fmt_str) - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_spec_deprecated_formatting(self): spec = Spec("libelf cflags=-O2") spec.concretize() @@ -929,8 +905,6 @@ class TestSpecSematics(object): actual = spec.format(named_str) assert str(expected) == actual - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.regression('9908') def test_spec_flags_maintain_order(self): # Spack was assembling flags in a manner that could result in @@ -997,8 +971,6 @@ class TestSpecSematics(object): with pytest.raises(SpecError): spec.prefix - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_forwarding_of_architecture_attributes(self): spec = Spec('libelf target=x86_64').concretized() @@ -1019,8 +991,6 @@ class TestSpecSematics(object): assert 'avx512' not in spec.target assert spec.target < 'broadwell' - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('transitive', [True, False]) def test_splice(self, transitive): # Tests the new splice function in Spec using a somewhat simple case @@ -1056,8 +1026,6 @@ class TestSpecSematics(object): # Finally, the spec should know it's been spliced: assert out.spliced - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('transitive', [True, False]) def test_splice_with_cached_hashes(self, transitive): spec = Spec('splice-t') @@ -1088,8 +1056,6 @@ class TestSpecSematics(object): assert (out['splice-h'].build_hash() == dep.build_hash()) == transitive assert out['splice-z'].build_hash() == out_z_expected.build_hash() - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('transitive', [True, False]) def test_splice_input_unchanged(self, transitive): spec = Spec('splice-t').concretized() @@ -1102,8 +1068,6 @@ class TestSpecSematics(object): assert spec.full_hash() == orig_spec_hash assert dep.full_hash() == orig_dep_hash - @pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize('transitive', [True, False]) def test_splice_subsequent(self, transitive): spec = Spec('splice-t') @@ -1208,8 +1172,6 @@ class TestSpecSematics(object): assert s.satisfies('mpileaks ^zmpi ^fake', strict=True) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.regression('3887') @pytest.mark.parametrize('spec_str', [ 'git', 'hdf5', 'py-flake8' diff --git a/lib/spack/spack/test/spec_syntax.py b/lib/spack/spack/test/spec_syntax.py index 681bf42659..48e55254f4 100644 --- a/lib/spack/spack/test/spec_syntax.py +++ b/lib/spack/spack/test/spec_syntax.py @@ -5,7 +5,6 @@ import itertools import os import shlex -import sys import pytest diff --git a/lib/spack/spack/test/spec_yaml.py b/lib/spack/spack/test/spec_yaml.py index b676653849..8aa14b9230 100644 --- a/lib/spack/spack/test/spec_yaml.py +++ b/lib/spack/spack/test/spec_yaml.py @@ -11,7 +11,6 @@ YAML format preserves DAG information in the spec. import ast import inspect import os -import sys import pytest diff --git a/lib/spack/spack/test/test_activations.py b/lib/spack/spack/test/test_activations.py index 915b4d2081..8eadfa837b 100644 --- a/lib/spack/spack/test/test_activations.py +++ b/lib/spack/spack/test/test_activations.py @@ -20,6 +20,10 @@ from spack.directory_layout import DirectoryLayout from spack.filesystem_view import YamlFilesystemView from spack.repo import RepoPath +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Python activation not \ + currently supported on Windows") + def create_ext_pkg(name, prefix, extendee_spec, monkeypatch): ext_spec = spack.spec.Spec(name) @@ -178,8 +182,6 @@ def test_python_activation_with_files(tmpdir, python_and_extension_dirs, assert 'setuptools.egg' not in easy_install_contents -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_python_activation_view(tmpdir, python_and_extension_dirs, builtin_and_mock_packages, monkeypatch): python_prefix, ext_prefix = python_and_extension_dirs @@ -203,8 +205,6 @@ def test_python_activation_view(tmpdir, python_and_extension_dirs, assert os.path.exists(os.path.join(view_dir, 'bin/py-ext-tool')) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_python_ignore_namespace_init_conflict( tmpdir, namespace_extensions, builtin_and_mock_packages, monkeypatch): """Test the view update logic in PythonPackage ignores conflicting @@ -239,8 +239,6 @@ def test_python_ignore_namespace_init_conflict( assert os.path.exists(os.path.join(view_dir, init_file)) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_python_keep_namespace_init( tmpdir, namespace_extensions, builtin_and_mock_packages, monkeypatch): """Test the view update logic in PythonPackage keeps the namespace @@ -283,8 +281,6 @@ def test_python_keep_namespace_init( assert not os.path.exists(os.path.join(view_dir, init_file)) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_python_namespace_conflict(tmpdir, namespace_extensions, monkeypatch, builtin_and_mock_packages): """Test the view update logic in PythonPackage reports an error when two diff --git a/lib/spack/spack/test/test_suite.py b/lib/spack/spack/test/test_suite.py index 419e633e9c..20d7172eea 100644 --- a/lib/spack/spack/test/test_suite.py +++ b/lib/spack/spack/test/test_suite.py @@ -12,9 +12,10 @@ import llnl.util.filesystem as fs import spack.install_test import spack.spec +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Tests fail on Windows") + -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_test_log_pathname(mock_packages, config): """Ensure test log path is reasonable.""" spec = spack.spec.Spec('libdwarf').concretized() @@ -28,8 +29,6 @@ def test_test_log_pathname(mock_packages, config): assert test_suite.test_log_name(spec) in logfile -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_test_ensure_stage(mock_test_stage): """Make sure test stage directory is properly set up.""" spec = spack.spec.Spec('libdwarf').concretized() @@ -43,8 +42,6 @@ def test_test_ensure_stage(mock_test_stage): assert mock_test_stage in test_suite.stage -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_write_test_result(mock_packages, mock_test_stage): """Ensure test results written to a results file.""" spec = spack.spec.Spec('libdwarf').concretized() @@ -65,7 +62,6 @@ def test_write_test_result(mock_packages, mock_test_stage): assert spec.name in msg -@pytest.mark.skipif(sys.platform == 'win32', reason="Not yet implemented on windows") def test_do_test(mock_packages, install_mockery, mock_test_stage): """Perform a stand-alone test with files to copy.""" spec = spack.spec.Spec('trivial-smoke-test').concretized() diff --git a/lib/spack/spack/test/url_fetch.py b/lib/spack/spack/test/url_fetch.py index d3155a45f0..8497fbebd7 100644 --- a/lib/spack/spack/test/url_fetch.py +++ b/lib/spack/spack/test/url_fetch.py @@ -163,6 +163,7 @@ def test_fetch( assert 'echo Building...' in contents +# TODO-27021 @pytest.mark.skipif(sys.platform == 'win32', reason="Not supported on Windows (yet)") @pytest.mark.parametrize('spec,url,digest', [ diff --git a/lib/spack/spack/test/util/editor.py b/lib/spack/spack/test/util/editor.py index f197682a97..e7c8bf2364 100644 --- a/lib/spack/spack/test/util/editor.py +++ b/lib/spack/spack/test/util/editor.py @@ -12,7 +12,9 @@ from llnl.util.filesystem import set_executable import spack.util.editor as ed -pytestmark = pytest.mark.usefixtures('working_env') +pytestmark = [pytest.mark.usefixtures('working_env'), + pytest.mark.skipif(sys.platform == 'win32', + reason="editor not implemented on windows")] def _make_exe(tmpdir_factory, name, contents=None): @@ -23,8 +25,6 @@ def _make_exe(tmpdir_factory, name, contents=None): with open(path, 'w') as f: f.write('#!/bin/sh\n%s\n' % contents) set_executable(path) - if sys.platform == "win32": - path = path.replace('\\', '/') return path @@ -48,13 +48,11 @@ def vim_exe(tmpdir_factory): return _make_exe(tmpdir_factory, 'vim', 'exit 0') -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_find_exe_from_env_var(good_exe): os.environ['EDITOR'] = good_exe assert ed._find_exe_from_env_var('EDITOR') == (good_exe, [good_exe]) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_find_exe_from_env_var_with_args(good_exe): os.environ['EDITOR'] = good_exe + ' a b c' assert ed._find_exe_from_env_var('EDITOR') == ( @@ -72,7 +70,6 @@ def test_find_exe_from_env_var_no_editor(): assert ed._find_exe_from_env_var('FOO') == (None, []) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_editor_visual(good_exe): os.environ['VISUAL'] = good_exe @@ -83,7 +80,6 @@ def test_editor_visual(good_exe): ed.editor('/path/to/file', _exec_func=assert_exec) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_editor_visual_bad(good_exe, bad_exe): os.environ['VISUAL'] = bad_exe os.environ['EDITOR'] = good_exe @@ -98,7 +94,6 @@ def test_editor_visual_bad(good_exe, bad_exe): ed.editor('/path/to/file', _exec_func=assert_exec) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_editor_no_visual(good_exe): if 'VISUAL' in os.environ: del os.environ['VISUAL'] @@ -111,7 +106,6 @@ def test_editor_no_visual(good_exe): ed.editor('/path/to/file', _exec_func=assert_exec) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_editor_no_visual_with_args(good_exe): if 'VISUAL' in os.environ: del os.environ['VISUAL'] @@ -126,7 +120,6 @@ def test_editor_no_visual_with_args(good_exe): ed.editor('/path/to/file', _exec_func=assert_exec) -@pytest.mark.skipif(sys.platform == 'win32', reason="editor not implemented on windows") def test_editor_both_bad(nosuch_exe, vim_exe): os.environ['VISUAL'] = nosuch_exe os.environ['EDITOR'] = nosuch_exe diff --git a/lib/spack/spack/test/util/environment.py b/lib/spack/spack/test/util/environment.py index 3604b7871b..1e28590e80 100644 --- a/lib/spack/spack/test/util/environment.py +++ b/lib/spack/spack/test/util/environment.py @@ -11,6 +11,8 @@ import pytest import spack.util.environment as envutil +is_windows = sys.platform == 'win32' + @pytest.fixture() def prepare_environment_for_tests(): @@ -20,25 +22,34 @@ def prepare_environment_for_tests(): del os.environ['TEST_ENV_VAR'] -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_is_system_path(): - assert(envutil.is_system_path('/usr/bin')) + sys_path = 'C:\\Users' if is_windows else '/usr/bin' + assert(envutil.is_system_path(sys_path)) assert(not envutil.is_system_path('/nonsense_path/bin')) assert(not envutil.is_system_path('')) assert(not envutil.is_system_path(None)) -test_paths = ['/usr/bin', - '/nonsense_path/lib', - '/usr/local/lib', - '/bin', - '/nonsense_path/extra/bin', - '/usr/lib64'] +if is_windows: + test_paths = [ + 'C:\\Users', + 'C:\\', + 'C:\\ProgramData', + 'C:\\nonsense_path', + 'C:\\Program Files', + 'C:\\nonsense_path\\extra\\bin'] +else: + test_paths = ['/usr/bin', + '/nonsense_path/lib', + '/usr/local/lib', + '/bin', + '/nonsense_path/extra/bin', + '/usr/lib64'] -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_filter_system_paths(): - expected = [p for p in test_paths if p.startswith('/nonsense_path')] + nonsense_prefix = 'C:\\nonsense_path' if is_windows else '/nonsense_path' + expected = [p for p in test_paths if p.startswith(nonsense_prefix)] filtered = envutil.filter_system_paths(test_paths) assert(expected == filtered) @@ -57,9 +68,8 @@ def test_prune_duplicate_paths(): assert(expected == envutil.prune_duplicate_paths(test_paths)) -@pytest.mark.skipif(sys.platform == 'win32', reason="All Fetchers Failed") def test_get_path(prepare_environment_for_tests): - os.environ['TEST_ENV_VAR'] = '/a:/b:/c/d' + os.environ['TEST_ENV_VAR'] = os.pathsep.join(['/a', '/b', '/c/d']) expected = ['/a', '/b', '/c/d'] assert(envutil.get_path('TEST_ENV_VAR') == expected) diff --git a/lib/spack/spack/test/util/executable.py b/lib/spack/spack/test/util/executable.py index 6a313e751f..ea9213f063 100644 --- a/lib/spack/spack/test/util/executable.py +++ b/lib/spack/spack/test/util/executable.py @@ -14,10 +14,16 @@ import spack import spack.util.executable as ex from spack.hooks.sbang import filter_shebangs_in_directory +is_windows = sys.platform == 'win32' + def test_read_unicode(tmpdir, working_env): script_name = 'print_unicode.py' - + # read the unicode back in and see whether things work + if is_windows: + script = ex.Executable('%s %s' % (sys.executable, script_name)) + else: + script = ex.Executable('./%s' % script_name) with tmpdir.as_cwd(): os.environ['LD_LIBRARY_PATH'] = spack.main.spack_ld_library_path # make a script that prints some unicode @@ -35,12 +41,6 @@ print(u'\\xc3') fs.set_executable(script_name) filter_shebangs_in_directory('.', [script_name]) - # read the unicode back in and see whether things work - if sys.platform == 'win32': - script = ex.Executable('%s %s' % (sys.executable, script_name)) - else: - script = ex.Executable('./%s' % script_name) - assert u'\xc3' == script(output=str).strip() @@ -54,9 +54,10 @@ def test_which_relative_path_with_slash(tmpdir, working_env): no_exe = ex.which('.{0}exe'.format(os.path.sep)) assert no_exe is None if sys.platform == "win32": - # For Windows, need to create files with .exe after any assert is none tests - tmpdir.ensure("exe.exe") + # These checks are for 'executable' files, Windows + # determines this by file extension. path += ".exe" + tmpdir.ensure('exe.exe') else: fs.set_executable(path) diff --git a/lib/spack/spack/test/util/file_cache.py b/lib/spack/spack/test/util/file_cache.py index 02056fd444..988e243835 100644 --- a/lib/spack/spack/test/util/file_cache.py +++ b/lib/spack/spack/test/util/file_cache.py @@ -5,7 +5,6 @@ """Test Spack's FileCache.""" import os -import sys import pytest @@ -30,8 +29,6 @@ def test_write_and_read_cache_file(file_cache): assert text == "foobar\n" -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_write_and_remove_cache_file(file_cache): """Test two write transactions on a cached file. Then try to remove an entry from it. diff --git a/lib/spack/spack/test/util/path.py b/lib/spack/spack/test/util/path.py index 13633195db..7d2b81e8b3 100644 --- a/lib/spack/spack/test/util/path.py +++ b/lib/spack/spack/test/util/path.py @@ -12,6 +12,12 @@ import llnl.util.tty as tty import spack.config import spack.util.path as sup +# This module pertains to path string padding manipulation specifically +# which is used for binary caching. This functionality is not supported +# on Windows as of yet. +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason="Tests fail on Windows") + #: Some lines with lots of placeholders padded_lines = [ "==> [2021-06-23-15:59:05.020387] './configure' '--prefix=/Users/gamblin2/padding-log-test/opt/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_placeholder__/__spack_path_pla/darwin-bigsur-skylake/apple-clang-12.0.5/zlib-1.2.11-74mwnxgn6nujehpyyalhwizwojwn5zga", # noqa: E501 @@ -28,24 +34,18 @@ fixed_lines = [ ] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") @pytest.mark.parametrize("padded,fixed", zip(padded_lines, fixed_lines)) def test_padding_substitution(padded, fixed): """Ensure that all padded lines are unpadded correctly.""" assert fixed == sup.padding_filter(padded) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_no_substitution(): """Ensure that a line not containing one full path placeholder is not modified.""" partial = "--prefix=/Users/gamblin2/padding-log-test/opt/__spack_path_pla/darwin-bigsur-skylake/apple-clang-12.0.5/zlib-1.2.11-74mwnxgn6nujehpyyalhwizwojwn5zga'" # noqa: E501 assert sup.padding_filter(partial) == partial -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_short_substitution(): """Ensure that a single placeholder path component is replaced""" short = "--prefix=/Users/gamblin2/padding-log-test/opt/__spack_path_placeholder__/darwin-bigsur-skylake/apple-clang-12.0.5/zlib-1.2.11-74mwnxgn6nujehpyyalhwizwojwn5zga'" # noqa: E501 @@ -53,8 +53,6 @@ def test_short_substitution(): assert short_subst == sup.padding_filter(short) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_partial_substitution(): """Ensure that a single placeholder path component is replaced""" short = "--prefix=/Users/gamblin2/padding-log-test/opt/__spack_path_placeholder__/__spack_p/darwin-bigsur-skylake/apple-clang-12.0.5/zlib-1.2.11-74mwnxgn6nujehpyyalhwizwojwn5zga'" # noqa: E501 @@ -72,8 +70,6 @@ def test_longest_prefix_re(): ) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_output_filtering(capfd, install_mockery, mutable_config): """Test filtering padding out of tty messages.""" long_path = "/" + "/".join([sup.SPACK_PATH_PADDING_CHARS] * 200) diff --git a/lib/spack/spack/test/util/util_url.py b/lib/spack/spack/test/util/util_url.py index b0316aaf3f..8e22c99164 100644 --- a/lib/spack/spack/test/util/util_url.py +++ b/lib/spack/spack/test/util/util_url.py @@ -7,19 +7,22 @@ import os import os.path import posixpath +import re import sys import pytest import spack.paths import spack.util.url as url_util +from spack.util.path import convert_to_posix_path + +is_windows = sys.platform == 'win32' +if is_windows: + drive_m = re.search(r'[A-Za-z]:', spack.paths.test_path) + drive = drive_m.group() if drive_m else None def test_url_parse(): - parsed = url_util.parse('/path/to/resource') - assert(parsed.scheme == 'file') - assert(parsed.netloc == '') - assert(parsed.path == '/path/to/resource') parsed = url_util.parse('/path/to/resource', scheme='fake') assert(parsed.scheme == 'fake') @@ -36,11 +39,20 @@ def test_url_parse(): assert(parsed.netloc == '') assert(parsed.path == '/path/to/resource') - if sys.platform != 'win32': - parsed = url_util.parse('file://path/to/resource') + parsed = url_util.parse('file://path/to/resource') + assert(parsed.scheme == 'file') + expected = convert_to_posix_path( + os.path.abspath( + posixpath.join('path', 'to', 'resource'))) + if is_windows: + expected = expected.lstrip(drive) + assert(parsed.path == expected) + + if is_windows: + parsed = url_util.parse('file://%s\\path\\to\\resource' % drive) assert(parsed.scheme == 'file') - expected = os.path.abspath(posixpath.join('path', 'to', 'resource')) - assert(parsed.path == expected) + expected = '/' + posixpath.join('path', 'to', 'resource') + assert parsed.path == expected parsed = url_util.parse('https://path/to/resource') assert(parsed.scheme == 'https') @@ -48,46 +60,34 @@ def test_url_parse(): assert(parsed.path == '/to/resource') spack_root = spack.paths.spack_root - parsed = url_util.parse('$spack') + parsed = url_util.parse('file://$spack') assert(parsed.scheme == 'file') - if sys.platform != 'win32': - assert(parsed.netloc == '') - if sys.platform == "win32": - spack_root = spack_root.replace('\\', '/') + if is_windows: + spack_root = '/' + convert_to_posix_path(spack_root) assert(parsed.netloc + parsed.path == spack_root) - # Test that sticking the spack root at the end of a posix path resolves - # correctly. - if sys.platform != "win32": - parsed = url_util.parse('/a/b/c/$spack') - assert(parsed.scheme == 'file') - assert(parsed.netloc == '') - expected = os.path.abspath(os.path.join( - '/', 'a', 'b', 'c', './' + spack_root)) - assert(parsed.path == expected) - def test_url_local_file_path(): spack_root = spack.paths.spack_root - + sep = os.path.sep lfp = url_util.local_file_path('/a/b/c.txt') - assert(lfp == '/a/b/c.txt') + assert(lfp == sep + os.path.join('a', 'b', 'c.txt')) lfp = url_util.local_file_path('file:///a/b/c.txt') - assert(lfp == '/a/b/c.txt') + assert(lfp == sep + os.path.join('a', 'b', 'c.txt')) - if sys.platform != "win32": + if is_windows: lfp = url_util.local_file_path('file://a/b/c.txt') expected = os.path.abspath(os.path.join('a', 'b', 'c.txt')) assert(lfp == expected) - lfp = url_util.local_file_path('$spack/a/b/c.txt') + lfp = url_util.local_file_path('file://$spack/a/b/c.txt') expected = os.path.abspath(os.path.join(spack_root, 'a', 'b', 'c.txt')) assert(lfp == expected) - if sys.platform != "win32": + if is_windows: lfp = url_util.local_file_path('file:///$spack/a/b/c.txt') expected = os.path.abspath(os.path.join(spack_root, 'a', 'b', 'c.txt')) assert(lfp == expected) @@ -285,7 +285,7 @@ def test_url_join_absolute_paths(): # ...to work out what resource it points to) if sys.platform == "win32": - cwd.replace('\\', '/') + convert_to_posix_path(cwd) cwd = '/' + cwd # So, even though parse() assumes "file://" URL, the scheme is still diff --git a/lib/spack/spack/test/verification.py b/lib/spack/spack/test/verification.py index fbfefab1c8..ad7373a439 100644 --- a/lib/spack/spack/test/verification.py +++ b/lib/spack/spack/test/verification.py @@ -18,9 +18,10 @@ import spack.store import spack.util.spack_json as sjson import spack.verify +pytestmark = pytest.mark.skipif(sys.platform == 'win32', + reason='Tests fail on Win') + -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_link_manifest_entry(tmpdir): # Test that symlinks are properly checked against the manifest. # Test that the appropriate errors are generated when the check fails. @@ -120,8 +121,6 @@ def test_file_manifest_entry(tmpdir): assert sorted(results.errors[file]) == sorted(expected) -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_check_chmod_manifest_entry(tmpdir): # Check that the verification properly identifies errors for files whose # permissions have been modified. @@ -195,8 +194,6 @@ def test_check_prefix_manifest(tmpdir): assert results.errors[spec.prefix] == ['manifest corrupted'] -@pytest.mark.skipif(sys.platform == 'win32', - reason="Not supported on Windows (yet)") def test_single_file_verification(tmpdir): # Test the API to verify a single file, including finding the package # to which it belongs diff --git a/lib/spack/spack/util/environment.py b/lib/spack/spack/util/environment.py index da91414af0..207a904073 100644 --- a/lib/spack/spack/util/environment.py +++ b/lib/spack/spack/util/environment.py @@ -28,8 +28,13 @@ import spack.util.executable as executable import spack.util.spack_json as sjson from spack.util.path import path_to_os_path, system_path_filter -system_paths = ['/', '/usr', '/usr/local'] -suffixes = ['bin', 'bin64', 'include', 'lib', 'lib64'] +is_windows = sys.platform == 'win32' + +system_paths = ['/', '/usr', '/usr/local'] if \ + not is_windows else ['C:\\', 'C:\\Program Files', + 'C:\\Program Files (x86)', 'C:\\Users', + 'C:\\ProgramData'] +suffixes = ['bin', 'bin64', 'include', 'lib', 'lib64'] if not is_windows else [] system_dirs = [os.path.join(p, s) for s in suffixes for p in system_paths] + \ system_paths diff --git a/lib/spack/spack/util/executable.py b/lib/spack/spack/util/executable.py index 9d8fe5f626..a278fd1f5d 100644 --- a/lib/spack/spack/util/executable.py +++ b/lib/spack/spack/util/executable.py @@ -14,7 +14,7 @@ from six import string_types, text_type import llnl.util.tty as tty import spack.error -from spack.util.path import Path, marshall_path, path_to_os_path, system_path_filter +from spack.util.path import Path, format_os_path, path_to_os_path, system_path_filter __all__ = ['Executable', 'which', 'ProcessError'] @@ -24,7 +24,7 @@ class Executable(object): def __init__(self, name): # necesary here for the shlex call to succeed - name = marshall_path(name, mode=Path.unix) + name = format_os_path(name, mode=Path.unix) self.exe = shlex.split(str(name)) # filter back to platform dependent path self.exe = path_to_os_path(*self.exe) @@ -82,7 +82,6 @@ class Executable(object): """ return self.exe[0] - # needs a small fixup to better handle URLS and the like def __call__(self, *args, **kwargs): """Run this executable in a subprocess. diff --git a/lib/spack/spack/util/file_cache.py b/lib/spack/spack/util/file_cache.py index 5f68911241..f9436ace73 100644 --- a/lib/spack/spack/util/file_cache.py +++ b/lib/spack/spack/util/file_cache.py @@ -170,7 +170,7 @@ class FileCache(object): os.unlink(self.cache_path(key)) finally: lock.release_write() - os.unlink(self._lock_path(key)) + lock.cleanup() class CacheError(SpackError): diff --git a/lib/spack/spack/util/lock.py b/lib/spack/spack/util/lock.py index ff3e0dd14b..75d5c653b6 100644 --- a/lib/spack/spack/util/lock.py +++ b/lib/spack/spack/util/lock.py @@ -45,6 +45,10 @@ class Lock(llnl.util.lock.Lock): # type: ignore[no-redef] if self._enable: super(Lock, self)._debug(*args) + def cleanup(self, *args): + if self._enable: + super(Lock, self).cleanup(*args) + def check_lock_safety(path): """Do some extra checks to ensure disabling locks is safe. diff --git a/lib/spack/spack/util/parallel.py b/lib/spack/spack/util/parallel.py index c64d0431f9..a931bba0c6 100644 --- a/lib/spack/spack/util/parallel.py +++ b/lib/spack/spack/util/parallel.py @@ -127,7 +127,7 @@ def parallel_map(func, arguments, max_processes=None, debug=False): RuntimeError: if any error occurred in the worker processes """ task_wrapper = Task(func) - if sys.platform != 'darwin': + if sys.platform != 'darwin' and sys.platform != 'win32': with pool(processes=num_processes(max_processes=max_processes)) as p: results = p.map(task_wrapper, arguments) else: diff --git a/lib/spack/spack/util/path.py b/lib/spack/spack/util/path.py index b56ec11ede..fd51acbce7 100644 --- a/lib/spack/spack/util/path.py +++ b/lib/spack/spack/util/path.py @@ -68,9 +68,13 @@ def is_path_url(path): return bool(url_tuple.scheme) and len(url_tuple.scheme) > 1 +def win_exe_ext(): + return '.exe' + + def path_to_os_path(*pths): """ - Takes an arbitrary number of postional parameters + Takes an arbitrary number of positional parameters converts each arguemnt of type string to use a normalized filepath separator, and returns a list of all values """ @@ -78,7 +82,7 @@ def path_to_os_path(*pths): for pth in pths: if type(pth) is str and\ not is_path_url(pth): - pth = marshall_path(pth, mode=Path.platform_path) + pth = convert_to_platform_path(pth) ret_pths.append(pth) return ret_pths @@ -89,7 +93,7 @@ def system_path_filter(_func=None, arg_slice=None): Optional slicing range can be specified to select specific arguments This decorator takes all (or a slice) of a method's positional arguments - and normalizes useage of filepath separators on a per platform basis. + and normalizes usage of filepath separators on a per platform basis. Note: **kwargs, urls, and any type that is not a string are ignored so in such cases where path normalization is required, that should be @@ -121,15 +125,18 @@ def system_path_filter(_func=None, arg_slice=None): def get_system_path_max(): # Choose a conservative default sys_max_path_length = 256 - try: - path_max_proc = subprocess.Popen(['getconf', 'PATH_MAX', '/'], - stdout=subprocess.PIPE, - stderr=subprocess.STDOUT) - proc_output = str(path_max_proc.communicate()[0].decode()) - sys_max_path_length = int(proc_output) - except (ValueError, subprocess.CalledProcessError, OSError): - tty.msg('Unable to find system max path length, using: {0}'.format( - sys_max_path_length)) + if is_windows: + sys_max_path_length = 260 + else: + try: + path_max_proc = subprocess.Popen(['getconf', 'PATH_MAX', '/'], + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT) + proc_output = str(path_max_proc.communicate()[0].decode()) + sys_max_path_length = int(proc_output) + except (ValueError, subprocess.CalledProcessError, OSError): + tty.msg('Unable to find system max path length, using: {0}'.format( + sys_max_path_length)) return sys_max_path_length @@ -148,18 +155,21 @@ class Path: else unix -def marshall_path(path, mode=Path.unix): +def format_os_path(path, mode=Path.unix): """ Format path to use consistent, platform specific - separators. + separators. Absolute paths are converted between + drive letters and a prepended '/' as per platform + requirement. Parameters: path (str): the path to be normalized, must be a string or expose the replace method. mode (Path): the path filesperator style to normalize the passed path to. Default is unix style, i.e. '/' - """ + if not path: + return path if mode == Path.windows: path = path.replace('/', '\\') else: @@ -168,11 +178,15 @@ def marshall_path(path, mode=Path.unix): def convert_to_posix_path(path): - return path.replace('\\', '/') + return format_os_path(path, mode=Path.unix) def convert_to_windows_path(path): - return path.replace('/', '\\') + return format_os_path(path, mode=Path.windows) + + +def convert_to_platform_path(path): + return format_os_path(path, mode=Path.platform_path) def substitute_config_variables(path): diff --git a/lib/spack/spack/util/url.py b/lib/spack/spack/util/url.py index 7f7554e838..d63498674b 100644 --- a/lib/spack/spack/util/url.py +++ b/lib/spack/spack/util/url.py @@ -8,7 +8,6 @@ Utility functions for parsing, formatting, and manipulating URLs. """ import itertools -import ntpath import posixpath import re import sys @@ -16,7 +15,13 @@ import sys import six.moves.urllib.parse as urllib_parse from six import string_types -import spack.util.path +from spack.util.path import ( + canonicalize_path, + convert_to_platform_path, + convert_to_posix_path, +) + +is_windows = sys.platform == 'win32' def _split_all(path): @@ -49,13 +54,11 @@ def local_file_path(url): url = parse(url) if url.scheme == 'file': - is_windows_path = (len(url.netloc) == 2 and - url.netloc[1] == ':' and - 'A' <= url.netloc[0] and - url.netloc[0] <= 'Z') - if is_windows_path: - return ntpath.abspath(ntpath.join(url.netloc, '\\', url.path)) - + if is_windows: + pth = convert_to_platform_path(url.netloc + url.path) + if re.search(r'^\\[A-Za-z]:', pth): + pth = pth.lstrip('\\') + return pth return url.path return None @@ -70,7 +73,11 @@ def parse(url, scheme='file'): Otherwise, the returned value is the same as urllib's urlparse() with allow_fragments=False. """ - + # guarantee a value passed in is of proper url format. Guarantee + # allows for easier string manipulation accross platforms + if isinstance(url, string_types): + require_url_format(url) + url = escape_file_url(url) url_obj = ( urllib_parse.urlparse(url, scheme=scheme, allow_fragments=False) if isinstance(url, string_types) else url) @@ -79,51 +86,25 @@ def parse(url, scheme='file'): scheme = (scheme or 'file').lower() - # This is the first way that a windows path can be parsed. - # (The user leaves out the file:// scheme.) - # examples: - # C:\\a\\b\\c - # X:/a/b/c - is_windows_path = (len(scheme) == 1 and 'a' <= scheme and scheme <= 'z') - if is_windows_path: - netloc = scheme.upper() + ':' - scheme = 'file' - if scheme == 'file': - # If the above windows path case did not hold, check the second case. - if not is_windows_path: - # This is the other way that a windows path can be parsed. - # (The user explicitly provides the file:// scheme.) - # examples: - # file://C:\\a\\b\\c - # file://X:/a/b/c - is_windows_path = (len(netloc) == 2 and - netloc[1] == ':' and - (('A' <= netloc[0] and netloc[0] <= 'Z') or - ('a' <= netloc[0] and netloc[0] <= 'z'))) - if is_windows_path: - netloc = netloc[0].upper() + ':' - - path = spack.util.path.canonicalize_path(netloc + path) - path = re.sub(r'\\', '/', path) - path = re.sub(r'^/+', '/', path) - if not is_windows_path: - netloc = '' + # (The user explicitly provides the file:// scheme.) + # examples: + # file://C:\\a\\b\\c + # file://X:/a/b/c + path = canonicalize_path(netloc + path) + path = re.sub(r'^/+', '/', path) + netloc = '' - # If canonicalize_path() returns a path with a drive letter (e.g.: on - # windows), we need to pop that part off from the head of the string. - # We also need to set netloc == that part to handle the case of a local - # file path being passed. (e.g.: file://../a/b/c) - update_netloc = (len(path) >= 2 and - path[1] == ':' and - (('A' <= path[0] and path[0] <= 'Z') or - ('a' <= path[0] and path[0] <= 'z'))) - if update_netloc: - netloc, path = path[:2], path[2:] + drive_ltr_lst = re.findall(r'[A-Za-z]:\\', path) + is_win_path = bool(drive_ltr_lst) + if is_windows and is_win_path: + drive_ltr = drive_ltr_lst[0].strip('\\') + path = re.sub(r'[\\]*' + drive_ltr, '', path) + netloc = '/' + drive_ltr.strip('\\') if sys.platform == "win32": - path = path.replace('\\', '/') + path = convert_to_posix_path(path) return urllib_parse.ParseResult(scheme=scheme, netloc=netloc, @@ -199,9 +180,11 @@ def join(base_url, path, *extra, **kwargs): 'file:///opt/spack' """ paths = [ - (x.replace('\\', '/') if isinstance(x, string_types) - else x.geturl().replace('\\', '/')) + (x) if isinstance(x, string_types) + else x.geturl() for x in itertools.chain((base_url, path), extra)] + + paths = [convert_to_posix_path(x) for x in paths] n = len(paths) last_abs_component = None scheme = '' @@ -296,7 +279,7 @@ def _join(base_url, path, *extra, **kwargs): base_path = posixpath.join('', *path_tokens) if sys.platform == "win32": - base_path = base_path.replace('\\', '/') + base_path = convert_to_posix_path(base_path) return format(urllib_parse.ParseResult(scheme=scheme, netloc=netloc, @@ -357,3 +340,16 @@ def parse_git_url(url): raise ValueError("bad port in git url: %s" % url) return (scheme, user, hostname, port, path) + + +def require_url_format(url): + ut = re.search(r'^(file://|http://|https://|ftp://|s3://|/)', url) + assert ut is not None + + +def escape_file_url(url): + drive_ltr = re.findall(r'[A-Za-z]:\\', url) + if is_windows and drive_ltr: + url = url.replace(drive_ltr[0], '/' + drive_ltr[0]) + + return url diff --git a/lib/spack/spack/util/web.py b/lib/spack/spack/util/web.py index b13bde2e98..d3a9d57607 100644 --- a/lib/spack/spack/util/web.py +++ b/lib/spack/spack/util/web.py @@ -32,6 +32,7 @@ import spack.util.gcs as gcs_util import spack.util.s3 as s3_util import spack.util.url as url_util from spack.util.compression import ALLOWED_ARCHIVE_TYPES +from spack.util.path import convert_to_posix_path if sys.version_info < (3, 0): # Python 2 had these in the HTMLParser package. @@ -114,7 +115,7 @@ def read_from_url(url, accept_content_type=None): url_scheme = url.scheme url = url_util.format(url) if sys.platform == "win32" and url_scheme == "file": - url = url.replace("\\", "/") + url = convert_to_posix_path(url) req = Request(url) content_type = None @@ -652,7 +653,7 @@ def find_versions_of_archive( versions = {} matched = set() for url in archive_urls + sorted(links): - url = url.replace("\\", "/") + url = convert_to_posix_path(url) if any(re.search(r, url) for r in regexes): try: ver = spack.url.parse_version(url) |