More test fixes

- Fix travis windows env
- Fix exception type in test_plat_win
- Finish converting tests in test_plat_other, fix exception type

.travis.yml

@@ -3,26 +3,31 @@ matrix:
   include:
     - os: windows
       language: sh
-      python: 3
+      python: "3.8"
+      env: "PATH=/c/Python38:/c/Python38/Scripts:$PATH"
       # Perform the manual steps on windows to install python3
       before_install:
-        - choco install python3 --params "/InstallDir:C:\Python"
-        - export PATH="/c/Python:/c/Python/Scripts:$PATH"
+        - choco install python --version=3.8.6
         - python -m pip install --upgrade pip
-        - python -m pip install pywin32
       before_script:
-        - export TOXENV=py3-win
-
+        - export TOXENV=py38
     - python: "2.7"
     - python: "3.4"
     - python: "3.5"
     - python: "3.6"
-    # Obtain Python 3.7 from xenial as per https://github.com/travis-ci/travis-ci/issues/9815
     - python: "3.7"
-      dist: xenial
+    - python: "3.8"
+    - python: "3.9"
+    - python: "nightly"  # 3.10
+      before_script:
+        - export TOXENV=py310
+    - python: "2.7"
+      arch: ppc64le
+    - python: "3.6"
+      arch: ppc64le
 install:
-  - pip install tox
+  - python -m pip install tox
 before_script:
   - export TOXENV=$(echo py$TRAVIS_PYTHON_VERSION | tr -d .)
 script:
-  - tox
+  - python -m tox

README.rst

@@ -24,7 +24,7 @@ Installation
 
 You can download it with pip::
 
-    pip install Send2Trash
+    python -m pip install -U send2trash
 
 or you can download the source from http://github.com/arsenetar/send2trash and install it with::
 

send2trash/IFileOperationProgressSink.py

@@ -0,0 +1,105 @@
+# Sample implementation of IFileOperationProgressSink that just prints
+# some basic info
+
+import pythoncom
+from win32com.shell import shell, shellcon
+from win32com.server.policy import DesignatedWrapPolicy
+
+
+class FileOperationProgressSink(DesignatedWrapPolicy):
+    _com_interfaces_ = [shell.IID_IFileOperationProgressSink]
+    _public_methods_ = [
+        "StartOperations",
+        "FinishOperations",
+        "PreRenameItem",
+        "PostRenameItem",
+        "PreMoveItem",
+        "PostMoveItem",
+        "PreCopyItem",
+        "PostCopyItem",
+        "PreDeleteItem",
+        "PostDeleteItem",
+        "PreNewItem",
+        "PostNewItem",
+        "UpdateProgress",
+        "ResetTimer",
+        "PauseTimer",
+        "ResumeTimer",
+    ]
+
+    def __init__(self):
+        self._wrap_(self)
+        self.newItem = None
+
+    def PreDeleteItem(self, flags, item):
+        # Can detect cases where to stop via flags and condition below, however the operation
+        # does not actual stop, we can resort to raising an exception as that does stop things
+        # but that may need some additional considerations before implementing.
+        return (
+            0 if flags & shellcon.TSF_DELETE_RECYCLE_IF_POSSIBLE else 0x80004005
+        )  # S_OK, or E_FAIL
+
+    def PostDeleteItem(self, flags, item, hrDelete, newlyCreated):
+        if newlyCreated:
+            self.newItem = newlyCreated.GetDisplayName(shellcon.SHGDN_FORPARSING)
+
+    def StartOperations(self):
+        pass
+
+    def FinishOperations(self, Result):
+        pass
+
+    def PreRenameItem(self, Flags, Item, NewName):
+        pass
+
+    def PostRenameItem(self, Flags, Item, NewName, hrRename, NewlyCreated):
+        pass
+
+    def PreMoveItem(self, Flags, Item, DestinationFolder, NewName):
+        pass
+
+    def PostMoveItem(
+        self, Flags, Item, DestinationFolder, NewName, hrMove, NewlyCreated
+    ):
+        pass
+
+    def PreCopyItem(self, Flags, Item, DestinationFolder, NewName):
+        pass
+
+    def PostCopyItem(
+        self, Flags, Item, DestinationFolder, NewName, hrCopy, NewlyCreated
+    ):
+        pass
+
+    def PreNewItem(self, Flags, DestinationFolder, NewName):
+        pass
+
+    def PostNewItem(
+        self,
+        Flags,
+        DestinationFolder,
+        NewName,
+        TemplateName,
+        FileAttributes,
+        hrNew,
+        NewItem,
+    ):
+        pass
+
+    def UpdateProgress(self, WorkTotal, WorkSoFar):
+        pass
+
+    def ResetTimer(self):
+        pass
+
+    def PauseTimer(self):
+        pass
+
+    def ResumeTimer(self):
+        pass
+
+
+def CreateSink():
+    return pythoncom.WrapObject(
+        FileOperationProgressSink(), shell.IID_IFileOperationProgressSink
+    )

send2trash/exceptions.py

@@ -2,7 +2,7 @@ import errno
 from .compat import PY3
 
 if PY3:
-    _permission_error = PermissionError
+    _permission_error = PermissionError  # noqa: F821
 else:
     _permission_error = OSError
 

send2trash/plat_other.py

@@ -111,10 +111,9 @@ def trash_move(src, dst, topdir=None):
     check_create(filespath)
     check_create(infopath)
 
+    with open(op.join(infopath, destname + INFO_SUFFIX), "w") as f:
+        f.write(info_for(src, topdir))
     os.rename(src, op.join(filespath, destname))
-    f = open(op.join(infopath, destname + INFO_SUFFIX), "w")
-    f.write(info_for(src, topdir))
-    f.close()
 
 
 def find_mount_point(path):

send2trash/plat_win_modern.py

@@ -11,6 +11,7 @@ from platform import version
 import pythoncom
 import pywintypes
 from win32com.shell import shell, shellcon
+from .IFileOperationProgressSink import CreateSink
 
 
 def send2trash(paths):
@@ -50,10 +51,11 @@ def send2trash(paths):
     # actually try to perform the operation, this section may throw a
     # pywintypes.com_error which does not seem to create as nice of an
     # error as OSError so wrapping with try to convert
+    sink = CreateSink()
     try:
         for path in paths:
             item = shell.SHCreateItemFromParsingName(path, None, shell.IID_IShellItem)
-            fileop.DeleteItem(item)
+            fileop.DeleteItem(item, sink)
         result = fileop.PerformOperations()
         aborted = fileop.GetAnyOperationsAborted()
         # if non-zero result or aborted throw an exception

setup.py

@@ -14,12 +14,13 @@ CLASSIFIERS = [
     "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
     "Topic :: Desktop Environment :: File Managers",
 ]
 
-LONG_DESCRIPTION = (
-    open("README.rst", "rt").read() + "\n\n" + open("CHANGES.rst", "rt").read()
-)
+with open("README.rst", "rt") as f1, open("CHANGES.rst", "rt") as f2:
+    LONG_DESCRIPTION = f1.read() + "\n\n" + f2.read()
 
 setup(
     name="Send2Trash",
@@ -36,4 +37,5 @@ setup(
     classifiers=CLASSIFIERS,
     extras_require={"win32": ["pywin32"]},
     project_urls={"Bug Reports": "https://github.com/arsenetar/send2trash/issues"},
+    entry_points={"console_scripts": ["send2trash=send2trash.__main__:main"]},
 )

tests/__init__.py

@@ -1,18 +0,0 @@
-import sys
-import unittest
-
-
-def TestSuite():
-    suite = unittest.TestSuite()
-    loader = unittest.TestLoader()
-    if sys.platform == "win32":
-        from . import test_plat_win
-
-        suite.addTests(loader.loadTestsFromModule(test_plat_win))
-    else:
-        from . import test_script_main
-        from . import test_plat_other
-
-        suite.addTests(loader.loadTestsFromModule(test_script_main))
-        suite.addTests(loader.loadTestsFromModule(test_plat_other))
-    return suite

tests/test_plat_other.py

@@ -1,25 +1,80 @@
 # encoding: utf-8
+import pytest
 import codecs
-import unittest
 import os
+import sys
 from os import path as op
-import send2trash.plat_other
-from send2trash.plat_other import send2trash as s2t
 from send2trash.compat import PY3
+from send2trash import TrashPermissionError
 
 try:
     from configparser import ConfigParser
 except ImportError:
     # py2
-    from ConfigParser import ConfigParser
+    from ConfigParser import ConfigParser  # noqa: F401
+
 from tempfile import mkdtemp, NamedTemporaryFile, mktemp
 import shutil
 import stat
-import sys
 
-# Could still use cleaning up. But no longer relies on ramfs.
+if sys.platform != "win32":
+    import send2trash.plat_other
+    from send2trash.plat_other import send2trash as s2t
 
-HOMETRASH = send2trash.plat_other.HOMETRASH
+    HOMETRASH = send2trash.plat_other.HOMETRASH
+else:
+    pytest.skip("Skipping non-windows tests", allow_module_level=True)
+
+
+@pytest.fixture
+def testfile():
+    file = NamedTemporaryFile(
+        dir=op.expanduser("~"), prefix="send2trash_test", delete=False
+    )
+    file.close()
+    yield file
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        name = op.basename(file.name)
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file.name):
+        os.remove(file.name)
+
+
+@pytest.fixture
+def testfiles():
+    files = list(
+        map(
+            lambda index: NamedTemporaryFile(
+                dir=op.expanduser("~"),
+                prefix="send2trash_test{}".format(index),
+                delete=False,
+            ),
+            range(10),
+        )
+    )
+    [file.close() for file in files]
+    yield files
+    filenames = [op.basename(file.name) for file in files]
+    [os.remove(op.join(HOMETRASH, "files", filename)) for filename in filenames]
+    [
+        os.remove(op.join(HOMETRASH, "info", filename + ".trashinfo"))
+        for filename in filenames
+    ]
+
+
+def test_trash(testfile):
+    s2t(testfile.name)
+    assert op.exists(testfile.name) is False
+
+
+def test_multitrash(testfiles):
+    filenames = [file.name for file in testfiles]
+    s2t(filenames)
+    assert any([op.exists(filename) for filename in filenames]) is False
 
 
 def touch(path):
@@ -27,100 +82,47 @@ def touch(path):
         os.utime(path, None)
 
 
-class TestHomeTrash(unittest.TestCase):
-    def setUp(self):
-        self.file = NamedTemporaryFile(
-            dir=op.expanduser("~"), prefix="send2trash_test", delete=False
-        )
-
-    def test_trash(self):
-        s2t(self.file.name)
-        self.assertFalse(op.exists(self.file.name))
-
-    def tearDown(self):
-        name = op.basename(self.file.name)
-        os.remove(op.join(HOMETRASH, "files", name))
-        os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
-
-
-class TestHomeMultiTrash(unittest.TestCase):
-    def setUp(self):
-        self.files = list(
-            map(
-                lambda index: NamedTemporaryFile(
-                    dir=op.expanduser("~"),
-                    prefix="send2trash_test{}".format(index),
-                    delete=False,
-                ),
-                range(10),
-            )
-        )
-
-    def test_multitrash(self):
-        filenames = [file.name for file in self.files]
-        s2t(filenames)
-        self.assertFalse(any([op.exists(filename) for filename in filenames]))
-
-    def tearDown(self):
-        filenames = [op.basename(file.name) for file in self.files]
-        [os.remove(op.join(HOMETRASH, "files", filename)) for filename in filenames]
-        [
-            os.remove(op.join(HOMETRASH, "info", filename + ".trashinfo"))
-            for filename in filenames
-        ]
-
-
 def _filesys_enc():
     enc = sys.getfilesystemencoding()
     # Get canonical name of codec
     return codecs.lookup(enc).name
 
 
-@unittest.skipIf(_filesys_enc() == "ascii", "ASCII filesystem")
-class TestUnicodeTrash(unittest.TestCase):
-    def setUp(self):
-        self.name = u"send2trash_tést1"
-        self.file = op.join(op.expanduser(b"~"), self.name.encode("utf-8"))
-        touch(self.file)
-
-    def test_trash_bytes(self):
-        s2t(self.file)
-        assert not op.exists(self.file)
-
-    def test_trash_unicode(self):
-        s2t(self.file.decode(sys.getfilesystemencoding()))
-        assert not op.exists(self.file)
-
-    def tearDown(self):
-        if op.exists(self.file):
-            os.remove(self.file)
-
-        trash_file = op.join(HOMETRASH, "files", self.name)
-        if op.exists(trash_file):
-            os.remove(trash_file)
-            os.remove(op.join(HOMETRASH, "info", self.name + ".trashinfo"))
+@pytest.fixture
+def testUnicodefile():
+    name = u"send2trash_tést1"
+    file = op.join(op.expanduser(b"~"), name.encode("utf-8"))
+    touch(file)
+    yield file
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file):
+        os.remove(file)
 
 
-#
-# Tests for files on some other volume than the user's home directory.
-#
-# What we need to stub:
-# * plat_other.get_dev (to make sure the file will not be on the home dir dev)
-# * os.path.ismount (to make our topdir look like a top dir)
-#
-class TestExtVol(unittest.TestCase):
-    def setUp(self):
-        self.trashTopdir = mkdtemp(prefix="s2t")
+@pytest.mark.skipif(_filesys_enc() == "ascii", reason="Requires Unicode filesystem")
+def test_trash_bytes(testUnicodefile):
+    s2t(testUnicodefile)
+    assert not op.exists(testUnicodefile)
+
+
+@pytest.mark.skipif(_filesys_enc() == "ascii", reason="Requires Unicode filesystem")
+def test_trash_unicode(testUnicodefile):
+    s2t(testUnicodefile.decode(sys.getfilesystemencoding()))
+    assert not op.exists(testUnicodefile)
+
+
+class ExtVol:
+    def __init__(self, path):
+        self.trashTopdir = path
         if PY3:
-            trashTopdir_b = os.fsencode(self.trashTopdir)
+            self.trashTopdir_b = os.fsencode(self.trashTopdir)
         else:
-            trashTopdir_b = self.trashTopdir
-        self.fileName = "test.txt"
-        self.filePath = op.join(self.trashTopdir, self.fileName)
-        touch(self.filePath)
-
-        self.old_ismount = old_ismount = op.ismount
-        self.old_getdev = send2trash.plat_other.get_dev
+            self.trashTopdir_b = self.trashTopdir
 
         def s_getdev(path):
             from send2trash.plat_other import is_parent
@@ -133,120 +135,97 @@ class TestExtVol(unittest.TestCase):
         def s_ismount(path):
             if op.realpath(path) in (
                 op.realpath(self.trashTopdir),
-                op.realpath(trashTopdir_b),
+                op.realpath(self.trashTopdir_b),
             ):
                 return True
             return old_ismount(path)
 
+        self.old_ismount = old_ismount = op.ismount
+        self.old_getdev = send2trash.plat_other.get_dev
         send2trash.plat_other.os.path.ismount = s_ismount
         send2trash.plat_other.get_dev = s_getdev
 
-    def tearDown(self):
+    def cleanup(self):
         send2trash.plat_other.get_dev = self.old_getdev
         send2trash.plat_other.os.path.ismount = self.old_ismount
         shutil.rmtree(self.trashTopdir)
 
 
-class TestTopdirTrash(TestExtVol):
-    def setUp(self):
-        TestExtVol.setUp(self)
-        # Create a .Trash dir w/ a sticky bit
-        self.trashDir = op.join(self.trashTopdir, ".Trash")
-        os.mkdir(self.trashDir, 0o777 | stat.S_ISVTX)
+@pytest.fixture
+def testExtVol():
+    trashTopdir = mkdtemp(prefix="s2t")
+    volume = ExtVol(trashTopdir)
+    fileName = "test.txt"
+    filePath = op.join(volume.trashTopdir, fileName)
+    touch(filePath)
+    yield volume, fileName, filePath
+    volume.cleanup()
 
-    def test_trash(self):
-        s2t(self.filePath)
-        self.assertFalse(op.exists(self.filePath))
-        self.assertTrue(
-            op.exists(op.join(self.trashDir, str(os.getuid()), "files", self.fileName))
+
+def test_trash_topdir(testExtVol):
+    trashDir = op.join(testExtVol[0].trashTopdir, ".Trash")
+    os.mkdir(trashDir, 0o777 | stat.S_ISVTX)
+
+    s2t(testExtVol[2])
+    assert op.exists(testExtVol[2]) is False
+    assert (
+        op.exists(op.join(trashDir, str(os.getuid()), "files", testExtVol[1])) is True
+    )
+    assert (
+        op.exists(
+            op.join(trashDir, str(os.getuid()), "info", testExtVol[1] + ".trashinfo",)
         )
-        self.assertTrue(
-            op.exists(
-                op.join(
-                    self.trashDir,
-                    str(os.getuid()),
-                    "info",
-                    self.fileName + ".trashinfo",
-                )
-            )
-        )
-        # info relative path (if another test is added, with the same fileName/Path,
-        # then it gets renamed etc.)
-        cfg = ConfigParser()
-        cfg.read(
+        is True
+    )
+    # info relative path (if another test is added, with the same fileName/Path,
+    # then it gets renamed etc.)
+    cfg = ConfigParser()
+    cfg.read(op.join(trashDir, str(os.getuid()), "info", testExtVol[1] + ".trashinfo"))
+    assert (testExtVol[1] == cfg.get("Trash Info", "Path", raw=True)) is True
+
+
+def test_trash_topdir_fallback(testExtVol):
+    s2t(testExtVol[2])
+    assert op.exists(testExtVol[2]) is False
+    assert (
+        op.exists(
             op.join(
-                self.trashDir, str(os.getuid()), "info", self.fileName + ".trashinfo"
+                testExtVol[0].trashTopdir,
+                ".Trash-" + str(os.getuid()),
+                "files",
+                testExtVol[1],
             )
         )
-        self.assertEqual(self.fileName, cfg.get("Trash Info", "Path", raw=True))
+        is True
+    )
 
 
-# Test .Trash-UID
-class TestTopdirTrashFallback(TestExtVol):
-    def test_trash(self):
-        touch(self.filePath)
-        s2t(self.filePath)
-        self.assertFalse(op.exists(self.filePath))
-        self.assertTrue(
-            op.exists(
-                op.join(
-                    self.trashTopdir,
-                    ".Trash-" + str(os.getuid()),
-                    "files",
-                    self.fileName,
-                )
+def test_trash_topdir_failure(testExtVol):
+    os.chmod(testExtVol[0].trashTopdir, 0o500)  # not writable to induce the exception
+    pytest.raises(TrashPermissionError, s2t, [testExtVol[2]])
+    os.chmod(testExtVol[0].trashTopdir, 0o700)  # writable to allow deletion
+
+
+def test_trash_symlink(testExtVol):
+    # Use mktemp (race conditioney but no symlink equivalent)
+    # Since is_parent uses realpath(), and our getdev uses is_parent,
+    # this should work
+    slDir = mktemp(prefix="s2t", dir=op.expanduser("~"))
+    os.mkdir(op.join(testExtVol[0].trashTopdir, "subdir"), 0o700)
+    filePath = op.join(testExtVol[0].trashTopdir, "subdir", testExtVol[1])
+    touch(filePath)
+    os.symlink(op.join(testExtVol[0].trashTopdir, "subdir"), slDir)
+    s2t(op.join(slDir, testExtVol[1]))
+    assert op.exists(filePath) is False
+    assert (
+        op.exists(
+            op.join(
+                testExtVol[0].trashTopdir,
+                ".Trash-" + str(os.getuid()),
+                "files",
+                testExtVol[1],
             )
         )
-
-
-# Test failure
-class TestTopdirFailure(TestExtVol):
-    def setUp(self):
-        TestExtVol.setUp(self)
-        os.chmod(self.trashTopdir, 0o500)  # not writable to induce the exception
-
-    def test_trash(self):
-        with self.assertRaises(OSError):
-            s2t(self.filePath)
-        self.assertTrue(op.exists(self.filePath))
-
-    def tearDown(self):
-        os.chmod(self.trashTopdir, 0o700)  # writable to allow deletion
-        TestExtVol.tearDown(self)
-
-
-# Make sure it will find the mount point properly for a file in a symlinked path
-class TestSymlink(TestExtVol):
-    def setUp(self):
-        TestExtVol.setUp(self)
-        # Use mktemp (race conditioney but no symlink equivalent)
-        # Since is_parent uses realpath(), and our getdev uses is_parent,
-        # this should work
-        self.slDir = mktemp(prefix="s2t", dir=op.expanduser("~"))
-
-        os.mkdir(op.join(self.trashTopdir, "subdir"), 0o700)
-        self.filePath = op.join(self.trashTopdir, "subdir", self.fileName)
-        touch(self.filePath)
-        os.symlink(op.join(self.trashTopdir, "subdir"), self.slDir)
-
-    def test_trash(self):
-        s2t(op.join(self.slDir, self.fileName))
-        self.assertFalse(op.exists(self.filePath))
-        self.assertTrue(
-            op.exists(
-                op.join(
-                    self.trashTopdir,
-                    ".Trash-" + str(os.getuid()),
-                    "files",
-                    self.fileName,
-                )
-            )
-        )
-
-    def tearDown(self):
-        os.remove(self.slDir)
-        TestExtVol.tearDown(self)
-
-
-if __name__ == "__main__":
-    unittest.main()
+        is True
+    )
+    os.remove(slDir)

tests/test_plat_win.py

@@ -1,154 +1,175 @@
-# coding: utf-8
+# encoding: utf-8
 import os
 import shutil
 import sys
-import unittest
+import pytest
 from os import path as op
-from tempfile import gettempdir
 
 from send2trash import send2trash as s2t
 
 # import the two versions as well as the "automatic" version
-from send2trash.plat_win_modern import send2trash as s2t_modern
-from send2trash.plat_win_legacy import send2trash as s2t_legacy
+if sys.platform == "win32":
+    from send2trash.plat_win_modern import send2trash as s2t_modern
+    from send2trash.plat_win_legacy import send2trash as s2t_legacy
+else:
+    pytest.skip("Skipping windows-only tests", allow_module_level=True)
 
 
-@unittest.skipIf(sys.platform != "win32", "Windows only")
-class TestNormal(unittest.TestCase):
-    def setUp(self):
-        self.dirname = "\\\\?\\" + op.join(gettempdir(), "python.send2trash")
-        self.file = op.join(self.dirname, "testfile.txt")
-        self._create_tree(self.file)
-        self.files = [
-            op.join(self.dirname, "testfile{}.txt".format(index)) for index in range(10)
-        ]
-        [self._create_tree(file) for file in self.files]
-
-    def tearDown(self):
-        shutil.rmtree(self.dirname, ignore_errors=True)
-
-    def _create_tree(self, path):
-        dirname = op.dirname(path)
-        if not op.isdir(dirname):
-            os.makedirs(dirname)
-        with open(path, "w") as writer:
-            writer.write("send2trash test")
-
-    def _trash_file(self, fcn):
-        fcn(self.file)
-        self.assertFalse(op.exists(self.file))
-
-    def _trash_multifile(self, fcn):
-        fcn(self.files)
-        self.assertFalse(any([op.exists(file) for file in self.files]))
-
-    def _file_not_found(self, fcn):
-        file = op.join(self.dirname, "otherfile.txt")
-        self.assertRaises(WindowsError, fcn, file)
-
-    def test_trash_file(self):
-        self._trash_file(s2t)
-
-    def test_trash_multifile(self):
-        self._trash_multifile(s2t)
-
-    def test_file_not_found(self):
-        self._file_not_found(s2t)
-
-    def test_trash_file_modern(self):
-        self._trash_file(s2t_modern)
-
-    def test_trash_multifile_modern(self):
-        self._trash_multifile(s2t_modern)
-
-    def test_file_not_found_modern(self):
-        self._file_not_found(s2t_modern)
-
-    def test_trash_file_legacy(self):
-        self._trash_file(s2t_legacy)
-
-    def test_trash_multifile_legacy(self):
-        self._trash_multifile(s2t_legacy)
-
-    def test_file_not_found_legacy(self):
-        self._file_not_found(s2t_legacy)
+def _create_tree(path):
+    dirname = op.dirname(path)
+    if not op.isdir(dirname):
+        os.makedirs(dirname)
+    with open(path, "w") as writer:
+        writer.write("send2trash test")
 
 
-@unittest.skipIf(sys.platform != "win32", "Windows only")
-class TestLongPath(unittest.TestCase):
-    def setUp(self):
-        self.functions = {s2t: "auto", s2t_legacy: "legacy", s2t_modern: "modern"}
-        filename = "A" * 100
-        self.dirname = "\\\\?\\" + op.join(gettempdir(), filename)
-        path = op.join(
-            self.dirname,
-            filename,
-            filename,  # From there, the path is not trashable from Explorer
-            filename,
-            filename + "{}.txt",
-        )
-        self.file = path.format("")
-        self._create_tree(self.file)
-        self.files = [path.format(index) for index in range(10)]
-        [self._create_tree(file) for file in self.files]
+@pytest.fixture
+def testdir(tmp_path):
+    dirname = "\\\\?\\" + str(tmp_path)
+    yield dirname
+    shutil.rmtree(dirname, ignore_errors=True)
 
-    def tearDown(self):
-        shutil.rmtree(self.dirname, ignore_errors=True)
 
-    def _create_tree(self, path):
-        dirname = op.dirname(path)
-        if not op.isdir(dirname):
-            os.makedirs(dirname)
-        with open(path, "w") as writer:
-            writer.write("Looong filename!")
+@pytest.fixture
+def testfile(testdir):
+    file = op.join(testdir, "testfile.txt")
+    _create_tree(file)
+    yield file
+    # Note dir will cleanup the file
 
-    def _trash_file(self, fcn):
-        fcn(self.file)
-        self.assertFalse(op.exists(self.file))
 
-    def _trash_multifile(self, fcn):
-        fcn(self.files)
-        self.assertFalse(any([op.exists(file) for file in self.files]))
+@pytest.fixture
+def testfiles(testdir):
+    files = [op.join(testdir, "testfile{}.txt".format(index)) for index in range(10)]
+    [_create_tree(file) for file in files]
+    yield files
+    # Note dir will cleanup the files
 
-    def _trash_folder(self, fcn):
-        fcn(self.dirname)
-        self.assertFalse(op.exists(self.dirname))
 
-    def test_trash_file(self):
-        self._trash_file(s2t)
+def _trash_folder(dir, fcn):
+    fcn(dir)
+    assert op.exists(dir) is False
 
-    def test_trash_multifile(self):
-        self._trash_multifile(s2t)
 
-    @unittest.skipIf(
-        op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
-        "Cannot trash long path from other drive",
-    )
-    def test_trash_folder(self):
-        self._trash_folder(s2t)
+def _trash_file(file, fcn):
+    fcn(file)
+    assert op.exists(file) is False
 
-    def test_trash_file_modern(self):
-        self._trash_file(s2t_modern)
 
-    def test_trash_multifile_modern(self):
-        self._trash_multifile(s2t_modern)
+def _trash_multifile(files, fcn):
+    fcn(files)
+    assert any([op.exists(file) for file in files]) is False
 
-    @unittest.skipIf(
-        op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
-        "Cannot trash long path from other drive",
-    )
-    def test_trash_folder_modern(self):
-        self._trash_folder(s2t_modern)
 
-    def test_trash_file_legacy(self):
-        self._trash_file(s2t_legacy)
+def _file_not_found(dir, fcn):
+    file = op.join(dir, "otherfile.txt")
+    pytest.raises(OSError, fcn, file)
 
-    def test_trash_multifile_legacy(self):
-        self._trash_multifile(s2t_legacy)
 
-    @unittest.skipIf(
-        op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
-        "Cannot trash long path from other drive",
-    )
-    def test_trash_folder_legacy(self):
-        self._trash_folder(s2t_legacy)
+def test_trash_folder(testdir):
+    _trash_folder(testdir, s2t)
+
+
+def test_trash_file(testfile):
+    _trash_file(testfile, s2t)
+
+
+def test_trash_multifile(testfiles):
+    _trash_multifile(testfiles, s2t)
+
+
+def test_file_not_found(testdir):
+    _file_not_found(testdir, s2t)
+
+
+def test_trash_folder_modern(testdir):
+    _trash_folder(testdir, s2t_modern)
+
+
+def test_trash_file_modern(testfile):
+    _trash_file(testfile, s2t_modern)
+
+
+def test_trash_multifile_modern(testfiles):
+    _trash_multifile(testfiles, s2t_modern)
+
+
+def test_file_not_found_modern(testdir):
+    _file_not_found(testdir, s2t_modern)
+
+
+def test_trash_folder_legacy(testdir):
+    _trash_folder(testdir, s2t_legacy)
+
+
+def test_trash_file_legacy(testfile):
+    _trash_file(testfile, s2t_legacy)
+
+
+def test_trash_multifile_legacy(testfiles):
+    _trash_multifile(testfiles, s2t_legacy)
+
+
+def test_file_not_found_legacy(testdir):
+    _file_not_found(testdir, s2t_legacy)
+
+
+# Long path tests
+@pytest.fixture
+def longdir(tmp_path):
+    dirname = "\\\\?\\" + str(tmp_path)
+    name = "A" * 100
+    yield op.join(dirname, name, name, name)
+    shutil.rmtree(dirname, ignore_errors=True)
+
+
+@pytest.fixture
+def longfile(longdir):
+    name = "A" * 100
+    path = op.join(longdir, name + "{}.txt")
+    file = path.format("")
+    _create_tree(file)
+    yield file
+
+
+@pytest.fixture
+def longfiles(longdir):
+    name = "A" * 100
+    path = op.join(longdir, name + "{}.txt")
+    files = [path.format(index) for index in range(10)]
+    [_create_tree(file) for file in files]
+    yield files
+
+
+# NOTE: both legacy and modern test "pass" on windows, but actually are not moving files to the
+# recycle bin, this was tested on latest windows 10, thought to have worked previously
+def test_trash_long_file_modern(longfile):
+    _trash_file(longfile, s2t_modern)
+
+
+def test_trash_long_multifile_modern(longfiles):
+    _trash_multifile(longfiles, s2t_modern)
+
+
+#     @pytest.skipif(
+#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+#         "Cannot trash long path from other drive",
+#     )
+#     def test_trash_long_folder_modern(self):
+#         self._trash_folder(s2t_modern)
+
+
+def test_trash_long_file_legacy(longfile):
+    _trash_file(longfile, s2t_legacy)
+
+
+def test_trash_long_multifile_legacy(longfiles):
+    _trash_multifile(longfiles, s2t_legacy)
+
+
+#     @pytest.skipif(
+#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+#         "Cannot trash long path from other drive",
+#     )
+#     def test_trash_long_folder_legacy(self):
+#         self._trash_folder(s2t_legacy)

tests/test_script_main.py

@@ -1,32 +1,41 @@
 # encoding: utf-8
 import os
-import unittest
+import sys
+import pytest
 from tempfile import NamedTemporaryFile
 from os import path as op
 
 from send2trash.__main__ import main as trash_main
-from tests.test_plat_other import HOMETRASH
+
+# Only import HOMETRASH on supported platforms
+if sys.platform != "win32":
+    from send2trash.plat_other import HOMETRASH
 
 
-class TestMainTrash(unittest.TestCase):
-    def setUp(self):
-        self.file = NamedTemporaryFile(dir=op.expanduser('~'), prefix='send2trash_test', delete=False)
-
-    def test_trash(self):
-        trash_main(['-v', self.file.name])
-        self.assertFalse(op.exists(self.file.name))
-
-    def test_no_args(self):
-        self.assertRaises(SystemExit, trash_main, [])
-        self.assertRaises(SystemExit, trash_main, ['-v'])
-        self.assertTrue(op.exists(self.file.name))
-        trash_main([self.file.name])  # Trash the file so tearDown runs properly
-
-    def tearDown(self):
-        name = op.basename(self.file.name)
-        os.remove(op.join(HOMETRASH, 'files', name))
-        os.remove(op.join(HOMETRASH, 'info', name + '.trashinfo'))
+@pytest.fixture
+def file():
+    file = NamedTemporaryFile(
+        dir=op.expanduser("~"), prefix="send2trash_test", delete=False
+    )
+    file.close()
+    yield file.name
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        name = op.basename(file.name)
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file.name):
+        os.remove(file.name)
 
 
-if __name__ == '__main__':
-    unittest.main()
+def test_trash(file):
+    trash_main(["-v", file])
+    assert op.exists(file) is False
+
+
+def test_no_args(file):
+    pytest.raises(SystemExit, trash_main, [])
+    pytest.raises(SystemExit, trash_main, ["-v"])
+    assert op.exists(file) is True

tox.ini

@@ -1,21 +1,20 @@
 [tox]
-envlist = py27,py34,py35,py36,py3-win
+envlist = py{27,34,35,36,37,38,39,310}
 skip_missing_interpreters = True
 
 [testenv]
-platform = linux
+deps =
+    flake8
+    pytest
+    pywin32; sys_platform == 'win32'
 commands =
-    python setup.py test --test-suite tests.TestSuite
-
-[testenv:py3-win]
-platform = win
-commands =
-    python -m pip install pywin32
-    python setup.py test --test-suite tests.TestSuite
+    flake8
+    pytest
 
 [testenv:py27]
 deps =
     configparser
+    {[testenv]deps}
 
 [flake8]
 exclude = .tox,env,build