Add CI on Windows and fix tests, update path handling (#92)

Author: epsy

.github/workflows/ci.yml

@@ -20,6 +20,22 @@ jobs:
     uses: epsy/python-workflows/.github/workflows/python-ci.yaml@main
     with:
       package-folder: clize
+  python-windows-ci:
+    name: "Run tests (Windows)"
+    runs-on: 'windows-latest'
+    continue-on-error: true
+    steps:
+      - uses: epsy/python-workflows/install-tox@main
+        with:
+          python-version: "3.10"
+      - name: Test with tox
+        uses: epsy/python-workflows/tox-ci@main
+        with:
+          tox-args: ""
+          python-test-args: "-m unittest"
+      - name: Verify that tox 'test' env ran
+        run: cat ./tox-proof-test
+        shell: bash
   mypy:
     name: "Run mypy on typed example"
     runs-on: 'ubuntu-latest'

clize/runner.py

@@ -1,9 +1,10 @@
 # clize -- A command-line argument parser for Python
 # Copyright (C) 2011-2016 by Yann Kaiser and contributors. See AUTHORS and
 # COPYING for details.
-
+import pathlib
 import sys
 import os
+import typing
 from functools import partial, update_wrapper
 import itertools
 import shutil
@@ -289,56 +290,49 @@ def cli(self):
         return c
 
 
-def fix_argv(argv, path, main):
-    """Properly display ``python -m`` invocations"""
-    if not path[0]:
-        try:
-            name = main_module_name(main)
-        except AttributeError:
-            pass
-        else:
-            argv = argv[:]
-            argv[0] = '{0} -m {1}'.format(
-                get_executable(sys.executable, 'python'), name)
-    else:
-        name = get_executable(argv[0], argv[0])
-        argv = argv[:]
-        argv[0] = name
-    return argv
-
-
-def get_executable(path, default):
+def _get_executable(path, *, to_path=pathlib.PurePath, which=shutil.which) -> typing.Union[None, str]:
+    """Get the shortest invocation for a given command"""
     if not path:
-        return default
-    if path.endswith('.py'):
-        return path
-    basename = os.path.basename(path)
-    try:
-        which = shutil.which
-    except AttributeError:
-        which = None
-    else:
-        if which(basename) == path:
-            return basename
+        return None
+    path = to_path(path)
+    which_result = which(path.name)
+    if which_result and to_path(which_result) == path:
+        return path.name
     try:
-        rel = os.path.relpath(path)
+        rel = path.relative_to(to_path())
     except ValueError:
-        return basename
-    if rel.startswith('../'):
-        if which is None and os.path.isabs(path):
-            return basename
-        return path
-    return rel
+        return str(path)
+    return str(rel)
 
 
 def main_module_name(module):
-    modname = os.path.splitext(os.path.basename(module.__file__))[0]
-    if modname == '__main__':
-        return module.__package__
-    elif not module.__package__:
-        return modname
+    try:
+        modname = os.path.splitext(os.path.basename(module.__file__))[0]
+        if modname == '__main__':
+            return module.__package__
+        elif not module.__package__:
+            return modname
+        else:
+            return module.__package__ + '.' + modname
+    except AttributeError:
+        return None
+
+
+def _fix_argv(argv, sys_path, main_module, *, platform=sys.platform, executable=sys.executable, get_executable=_get_executable, get_main_module_name=main_module_name):
+    """Tries to restore the given sys.argv to something closer to what the user would've typed"""
+    if not sys_path[0]:
+        name = get_main_module_name(main_module)
+        if name is not None:
+            argv = argv[:]
+            argv[0] = f'{get_executable(executable) or "python"} -m {name}'
+    elif platform.startswith("win"):
+        argv = argv[:]
+        argv[0] = f'{get_executable(executable) or "python"} {argv[0]}'
     else:
-        return module.__package__ + '.' + modname
+        name = get_executable(argv[0])
+        argv = argv[:]
+        argv[0] = name
+    return argv
 
 
 @autokwoargs
@@ -370,7 +364,7 @@ def run(args=None, catch=(), exit=True, out=None, err=None, *fn, **kwargs):
         # python2.7 -m apackage
         # is used
         module = sys.modules['__main__']
-        args = fix_argv(sys.argv, sys.path, module)
+        args = _fix_argv(sys.argv, sys.path, module)
     if out is None:
         out = sys.stdout
     if err is None:

clize/tests/test_converters.py

@@ -1,7 +1,7 @@
 # clize -- A command-line argument parser for Python
 # Copyright (C) 2011-2016 by Yann Kaiser and contributors. See AUTHORS and
 # COPYING for details.
-
+import unittest
 from datetime import datetime
 import tempfile
 import shutil
@@ -37,13 +37,19 @@ def _test(self, conv, inp, out, *, make_signature):
         converters.datetime, '2014-01-01 12:00', datetime(2014, 1, 1, 12, 0))
 
 
+skip_if_windows = unittest.skipIf(sys.platform.startswith("win"), "Unsupported on Windows")
+
+
 class FileConverterTests(Tests):
     def setUp(self):
         self.temp = tempfile.mkdtemp()
         self.completed = False
 
     def tearDown(self):
-        shutil.rmtree(self.temp)
+        def set_writable_and_retry(func, path, excinfo):
+            os.chmod(path, stat.S_IWUSR)
+            func(path)
+        shutil.rmtree(self.temp, set_writable_and_retry)
 
     def run_conv(self, conv, path):
         sig = support.s('*, par: c', globals={'c': conv})
@@ -175,6 +181,7 @@ def test_noperm_file_write(self):
         self.assertRaises(errors.BadArgumentFormat,
                           self.run_conv, converters.file(mode='w'), path)
 
+    @skip_if_windows
     def test_noperm_dir(self):
         dpath = os.path.join(self.temp, 'adir')
         path = os.path.join(self.temp, 'adir/afile')

clize/tests/test_runner.py

@@ -2,14 +2,16 @@
 # Copyright (C) 2011-2016 by Yann Kaiser and contributors. See AUTHORS and
 # COPYING for details.
 
-import os
+import pathlib
 import sys
-import shutil
 import unittest
 from io import StringIO
 
-from clize.tests.util import Fixtures, Tests
+import repeated_test
+from repeated_test import options
+
 from clize import runner, errors
+from clize.tests.util import Fixtures, Tests
 
 
 class MockModule(object):
@@ -43,107 +45,96 @@ def _test(self, filename, name, package, result):
 
     def test_pudb_script(self):
         module = BadModule(sp+'pack/cli.py', '__main__')
-        self.assertRaises(AttributeError, runner.main_module_name, module)
+        self.assertEqual(None, runner.main_module_name(module))
 
 
-class GetExcecutableTests(Fixtures):
-    def _test(self, path, default, result, which='/usr/bin'):
-        which_backup = getattr(shutil, 'which', None)
-        def which_(name, *args, **kwargs):
+@repeated_test.with_options_matrix(
+    to_path=[pathlib.PurePosixPath, pathlib.PureWindowsPath]
+)
+class GetExecutableTests(Fixtures):
+    def _test(self, path, expected, *, which=None, to_path):
+        def which_(name):
             if which:
-                return os.path.join('/usr/bin', name)
+                return str(to_path(which, name))
             else:
                 return None
-        shutil.which = which_
-        if which is None:
-            del shutil.which
-        try:
-            ret = runner.get_executable(path, default)
-            self.assertEqual(ret, result)
-        finally:
-            if which_backup:
-                shutil.which = which_backup
-            elif which is not None:
-                del shutil.which
-
-    none = None, 'python', 'python'
-    empty = '', 'myapp', 'myapp'
-    dotpy = '/a/path/leading/to/myapp.py', None, '/a/path/leading/to/myapp.py'
-    in_path = '/usr/bin/myapp', None, 'myapp'
-    in_path_2 = '/usr/bin/myapp', None, 'myapp', None
-    not_in_path = '/opt/myapp/bin/myapp', None, '/opt/myapp/bin/myapp'
-    relpath = 'myapp/bin/myapp', None, 'myapp/bin/myapp', ''
-    parentpath = '../myapp/bin/myapp', None, '../myapp/bin/myapp', ''
-    parentpath_2 = '../myapp/bin/myapp', None, '../myapp/bin/myapp', None
-
-    def test_run_with_no_which(self):
-        try:
-            which_backup = shutil.which
-        except AttributeError: # pragma: no cover
-            return
-        del shutil.which
-        try:
-            self._test(*GetExcecutableTests.empty)
-            self.assertFalse(hasattr(shutil, 'which'))
-            self._test(*GetExcecutableTests.in_path_2)
-            self.assertFalse(hasattr(shutil, 'which'))
-        finally:
-            shutil.which = which_backup
+        ret = runner._get_executable(path, which=which_, to_path=to_path)
+        self.assertEqual(ret, expected)
+
+    none = None, None
+    empty = '', None
+
+    with options(to_path=pathlib.PurePosixPath):
+        posix_dotpy = '/a/path/leading/to/myapp.py', '/a/path/leading/to/myapp.py'
+        posix_in_path = '/usr/bin/myapp', 'myapp', options(which='/usr/bin')
+        posix_not_in_path = '/opt/myapp/bin/myapp', '/opt/myapp/bin/myapp'
+        posix_not_from_path = '/opt/myapp/bin/myapp', '/opt/myapp/bin/myapp', options(which='/usr/bin')
+        posix_relpath = 'myapp/bin/myapp', 'myapp/bin/myapp', options(which='')
+        posix_parentpath_also_in_path = '../myapp/bin/myapp', '../myapp/bin/myapp', options(which='')
+        posix_parentpath = '../myapp/bin/myapp', '../myapp/bin/myapp', options(which=None)
+
+    with options(to_path=pathlib.PureWindowsPath):
+        win_dotpy = "C:/a/path/leading/to/myapp.py", r"C:\a\path\leading\to\myapp.py"
+        win_in_path = 'C:/Program Files/myapp/bin/myapp.py', 'myapp.py', options(which='C:/Program Files/myapp/bin/')
+        win_not_in_path = 'C:/Users/Myself/Documents/myapp', r'C:\Users\Myself\Documents\myapp'
+        win_not_from_path = 'C:/Users/Myself/Documents/myapp', r'C:\Users\Myself\Documents\myapp', options(which='C:/system32')
+        win_relpath = './my/folder/myapp.py', r'my\folder\myapp.py', options(which=None)
+        win_parentpath_also_in_path = '../myapp/bin/myapp', r'..\myapp\bin\myapp', options(which='')
+        win_parentpath = '../myapp/bin/myapp', r'..\myapp\bin\myapp', options(which=None)
+        win_diff_drives = 'D:/myapp/bin/myapp', r"D:\myapp\bin\myapp", options(which="C:/myapp/bin/myapp")
 
 
-def get_executable(path, default):
-    return default
+def get_executable_verbatim(path):
+    return path
 
 
+@repeated_test.with_options_matrix(platform=["anythingreally", "win32"], executable=["interpreter"], get_executable=[get_executable_verbatim])
 class FixArgvTests(Fixtures):
-    def _test(self, argv, path, main, expect):
-        def get_executable(path, default):
-            return default
-        _get_executable = runner.get_executable
-        runner.get_executable = get_executable
-        try:
-            module = MockModule(*main)
-            self.assertEqual(expect, runner.fix_argv(argv, path, module))
-        finally:
-            runner.get_executable = _get_executable
+    def _test(self, argv, path, main, expect, *, platform, executable, get_executable):
+        module = MockModule(*main)
+        self.assertEqual(expect, runner._fix_argv(argv, path, module, executable=executable, platform=platform, get_executable=get_executable))
 
     plainfile = (
         ['afile.py', '...'], ['/path/to/cwd', '/usr/lib/pythonX.Y'],
         ['afile.py', '__main__', None],
-        ['afile.py', '...']
-        )
+        ['afile.py', '...'],
+        options(platform="anythingreally"),
+    )
+
+    plainfile_win = (
+        ['afile.py', '...'], ['/path/to/cwd', '/usr/lib/pythonX.Y'],
+        ['afile.py', '__main__', None],
+        ['interpreter afile.py', '...'],
+        options(platform="win32"),
+    )
+
     asmodule = (
         ['/path/to/cwd/afile.py', '...'], ['', '/usr/lib/pythonX.Y'],
         ['/path/to/cwd/afile.py', '__main__', ''],
-        ['python -m afile', '...']
+        ['interpreter -m afile', '...']
         )
     packedmodule = (
         ['/path/to/cwd/apkg/afile.py', '...'], ['', '/usr/lib/pythonX.Y'],
         ['/path/to/cwd/apkg/afile.py', '__main__', 'apkg'],
-        ['python -m apkg.afile', '...']
+        ['interpreter -m apkg.afile', '...']
         )
     packedmain2 = (
         ['/path/to/cwd/apkg/__main__.py', '...'], ['', '/usr/lib/pythonX.Y'],
         ['/path/to/cwd/apkg/__main__.py', 'apkg.__main__', 'apkg'],
-        ['python -m apkg', '...']
+        ['interpreter -m apkg', '...']
         )
     packedmain3 = (
         ['/path/to/cwd/apkg/__main__.py', '...'], ['', '/usr/lib/pythonX.Y'],
         ['/path/to/cwd/apkg/__main__.py', '__main__', 'apkg'],
-        ['python -m apkg', '...']
+        ['interpreter -m apkg', '...']
         )
 
     def test_bad_fakemodule(self):
-        back = runner.get_executable
-        runner.get_executable = get_executable
-        try:
-            module = BadModule('/path/to/cwd/afile.py', '__main__')
-            argv = ['afile.py', '...']
-            path = ['', '/usr/lib/pythonX.Y']
-            self.assertEqual(['afile.py', '...'],
-                             runner.fix_argv(argv, path, module))
-        finally:
-            runner.get_executable = back
+        module = BadModule('/path/to/cwd/afile.py', '__main__')
+        argv = ['afile.py', '...']
+        path = ['', '/usr/lib/pythonX.Y']
+        self.assertEqual(['afile.py', '...'],
+                         runner._fix_argv(argv, path, module, get_executable=lambda p: ''))
 
 
 class GetCliTests(unittest.TestCase):
@@ -511,27 +502,24 @@ def test_run_sysargv(self):
         bmodules = sys.modules
         bargv = sys.argv
         bpath = sys.path
-        bget_executable = runner.get_executable
         try:
             sys.modules['__main__'] \
                 = MockModule('/path/to/cwd/afile.py', '__main__', '')
             sys.argv = ['afile.py', '...']
             sys.path = [''] + sys.path[1:]
-            runner.get_executable = get_executable
             def func(arg=1):
                 raise NotImplementedError
             out = StringIO()
             err = StringIO()
             runner.run(func, exit=False, out=out, err=err)
             self.assertFalse(out.getvalue())
-            self.assertEqual(err.getvalue(),
-                "python -m afile: Bad value for arg: '...'\n"
-                "Usage: python -m afile [arg]\n")
+            self.assertRegex(err.getvalue(),
+                ".* -m afile: Bad value for arg: '...'\n"
+                r"Usage: .* -m afile \[arg\]" "\n")
         finally:
             sys.modules = bmodules
             sys.argv = bargv
             sys.path = bpath
-            runner.get_executable = bget_executable
 
     def test_run_out(self):
         bout = sys.stdout

clize/tests/test_testutil.py

@@ -1,4 +1,4 @@
-from . import util
+from clize.tests import util
 
 
 class AssertLinesEqualTests(util.Fixtures):