Subject: fix tests
Description: remove network related tests as well
 tests opening local port (need root).
 Also remove doc from python package (will be in debian dir).
Forwarded: no
Last-Updated: 2019-07-30
Author: Olivier Sallou <osallou@debian.org>

--- a/test/test_real_ftp.py
+++ b/test/test_real_ftp.py
@@ -100,611 +100,6 @@
                 pass
 
 
-class RealFTPTest(object):
-
-    def setup_method(self, method):
-        # Server, username, password.
-        self.login_data = ("localhost", "ftptest",
-                            "d605581757de5eb56d568a4419f4126e")
-        self.host = ftputil.FTPHost(*self.login_data)
-        self.cleaner = Cleaner(self.host)
-
-    def teardown_method(self, method):
-        self.cleaner.clean()
-        self.host.close()
-
-    #
-    # Helper methods
-    #
-    def make_remote_file(self, path):
-        """Create a file on the FTP host."""
-        self.cleaner.add_file(path)
-        with self.host.open(path, "wb") as file_:
-            # Write something. Otherwise the FTP server might not update
-            # the time of last modification if the file existed before.
-            file_.write(b"\n")
-
-    def make_local_file(self):
-        """Create a file on the local host (= on the client side)."""
-        with open("_local_file_", "wb") as fobj:
-            fobj.write(b"abc\x12\x34def\t")
-
-
-class TestMkdir(RealFTPTest):
-
-    def test_mkdir_rmdir(self):
-        host = self.host
-        dir_name = "_testdir_"
-        file_name = host.path.join(dir_name, "_nonempty_")
-        self.cleaner.add_dir(dir_name)
-        # Make dir and check if the directory is there.
-        host.mkdir(dir_name)
-        files = host.listdir(host.curdir)
-        assert dir_name in files
-        # Try to remove a non-empty directory.
-        self.cleaner.add_file(file_name)
-        non_empty = host.open(file_name, "w")
-        non_empty.close()
-        with pytest.raises(ftputil.error.PermanentError):
-            host.rmdir(dir_name)
-        # Remove file.
-        host.unlink(file_name)
-        # `remove` on a directory should fail.
-        try:
-            try:
-                host.remove(dir_name)
-            except ftputil.error.PermanentError as exc:
-                assert str(exc).startswith(
-                         "remove/unlink can only delete files")
-            else:
-                pytest.fail("we shouldn't have come here")
-        finally:
-            # Delete empty directory.
-            host.rmdir(dir_name)
-        files = host.listdir(host.curdir)
-        assert dir_name not in files
-
-    def test_makedirs_without_existing_dirs(self):
-        host = self.host
-        # No `_dir1_` yet
-        assert "_dir1_" not in host.listdir(host.curdir)
-        # Vanilla case, all should go well.
-        host.makedirs("_dir1_/dir2/dir3/dir4")
-        self.cleaner.add_dir("_dir1_")
-        # Check host.
-        assert host.path.isdir("_dir1_")
-        assert host.path.isdir("_dir1_/dir2")
-        assert host.path.isdir("_dir1_/dir2/dir3")
-        assert host.path.isdir("_dir1_/dir2/dir3/dir4")
-
-    def test_makedirs_from_non_root_directory(self):
-        # This is a testcase for issue #22, see
-        # http://ftputil.sschwarzer.net/trac/ticket/22 .
-        host = self.host
-        # No `_dir1_` and `_dir2_` yet
-        assert "_dir1_" not in host.listdir(host.curdir)
-        assert "_dir2_" not in host.listdir(host.curdir)
-        # Part 1: Try to make directories starting from `_dir1_` and
-        # change to non-root directory.
-        self.cleaner.add_dir("_dir1_")
-        host.mkdir("_dir1_")
-        host.chdir("_dir1_")
-        host.makedirs("_dir2_/_dir3_")
-        # Test for expected directory hierarchy.
-        assert host.path.isdir("/_dir1_")
-        assert host.path.isdir("/_dir1_/_dir2_")
-        assert host.path.isdir("/_dir1_/_dir2_/_dir3_")
-        assert not host.path.isdir("/_dir1_/_dir1_")
-        # Remove all but the directory we're in.
-        host.rmdir("/_dir1_/_dir2_/_dir3_")
-        host.rmdir("/_dir1_/_dir2_")
-        # Part 2: Try to make directories starting from root.
-        self.cleaner.add_dir("/_dir2_")
-        host.makedirs("/_dir2_/_dir3_")
-        # Test for expected directory hierarchy
-        assert host.path.isdir("/_dir2_")
-        assert host.path.isdir("/_dir2_/_dir3_")
-        assert not host.path.isdir("/_dir1_/_dir2_")
-
-    def test_makedirs_of_existing_directory(self):
-        host = self.host
-        # The (chrooted) login directory
-        host.makedirs("/")
-
-    def test_makedirs_with_file_in_the_way(self):
-        host = self.host
-        self.cleaner.add_dir("_dir1_")
-        host.mkdir("_dir1_")
-        self.make_remote_file("_dir1_/file1")
-        # Try it.
-        with pytest.raises(ftputil.error.PermanentError):
-            host.makedirs("_dir1_/file1")
-        with pytest.raises(ftputil.error.PermanentError):
-            host.makedirs("_dir1_/file1/dir2")
-
-    def test_makedirs_with_existing_directory(self):
-        host = self.host
-        self.cleaner.add_dir("_dir1_")
-        host.mkdir("_dir1_")
-        host.makedirs("_dir1_/dir2")
-        # Check
-        assert host.path.isdir("_dir1_")
-        assert host.path.isdir("_dir1_/dir2")
-
-    def test_makedirs_in_non_writable_directory(self):
-        host = self.host
-        # Preparation: `rootdir1` exists but is only writable by root.
-        with pytest.raises(ftputil.error.PermanentError):
-            host.makedirs("rootdir1/dir2")
-
-    def test_makedirs_with_writable_directory_at_end(self):
-        host = self.host
-        self.cleaner.add_dir("rootdir2/dir2")
-        # Preparation: `rootdir2` exists but is only writable by root.
-        # `dir2` is writable by regular ftp users. Both directories
-        # below should work.
-        host.makedirs("rootdir2/dir2")
-        host.makedirs("rootdir2/dir2/dir3")
-
-
-class TestRemoval(RealFTPTest):
-
-    def test_rmtree_without_error_handler(self):
-        host = self.host
-        # Build a tree.
-        self.cleaner.add_dir("_dir1_")
-        host.makedirs("_dir1_/dir2")
-        self.make_remote_file("_dir1_/file1")
-        self.make_remote_file("_dir1_/file2")
-        self.make_remote_file("_dir1_/dir2/file3")
-        self.make_remote_file("_dir1_/dir2/file4")
-        # Try to remove a _file_ with `rmtree`.
-        with pytest.raises(ftputil.error.PermanentError):
-            host.rmtree("_dir1_/file2")
-        # Remove `dir2`.
-        host.rmtree("_dir1_/dir2")
-        assert not host.path.exists("_dir1_/dir2")
-        assert host.path.exists("_dir1_/file2")
-        # Re-create `dir2` and remove `_dir1_`.
-        host.mkdir("_dir1_/dir2")
-        self.make_remote_file("_dir1_/dir2/file3")
-        self.make_remote_file("_dir1_/dir2/file4")
-        host.rmtree("_dir1_")
-        assert not host.path.exists("_dir1_")
-
-    def test_rmtree_with_error_handler(self):
-        host = self.host
-        self.cleaner.add_dir("_dir1_")
-        host.mkdir("_dir1_")
-        self.make_remote_file("_dir1_/file1")
-        # Prepare error "handler"
-        log = []
-        def error_handler(*args):
-            log.append(args)
-        # Try to remove a file as root "directory".
-        host.rmtree("_dir1_/file1", ignore_errors=True, onerror=error_handler)
-        assert log == []
-        host.rmtree("_dir1_/file1", ignore_errors=False, onerror=error_handler)
-        assert log[0][0] == host.listdir
-        assert log[0][1] == "_dir1_/file1"
-        assert log[1][0] == host.rmdir
-        assert log[1][1] == "_dir1_/file1"
-        host.rmtree("_dir1_")
-        # Try to remove a non-existent directory.
-        del log[:]
-        host.rmtree("_dir1_", ignore_errors=False, onerror=error_handler)
-        assert log[0][0] == host.listdir
-        assert log[0][1] == "_dir1_"
-        assert log[1][0] == host.rmdir
-        assert log[1][1] == "_dir1_"
-
-    def test_remove_non_existent_item(self):
-        host = self.host
-        with pytest.raises(ftputil.error.PermanentError):
-            host.remove("nonexistent")
-
-    def test_remove_existing_file(self):
-        self.cleaner.add_file("_testfile_")
-        self.make_remote_file("_testfile_")
-        host = self.host
-        assert host.path.isfile("_testfile_")
-        host.remove("_testfile_")
-        assert not host.path.exists("_testfile_")
-
-
-class TestWalk(RealFTPTest):
-    """
-    Walk the directory tree
-
-      walk_test
-      ├── dir1
-      │   ├── dir11
-      │   └── dir12
-      │       ├── dir123
-      │       │   └── file1234
-      │       ├── file121
-      │       └── file122
-      ├── dir2
-      ├── dir3
-      │   ├── dir31
-      │   ├── dir32 -> ../dir1/dir12/dir123
-      │   ├── file31
-      │   └── file32
-      └── file4
-
-    and check if the results are the expected ones.
-    """
-
-    def _walk_test(self, expected_result, **walk_kwargs):
-        """Walk the directory and test results."""
-        # Collect data using `walk`.
-        actual_result = []
-        for items in self.host.walk(**walk_kwargs):
-            actual_result.append(items)
-        # Compare with expected results.
-        assert len(actual_result) == len(expected_result)
-        for index, _ in enumerate(actual_result):
-            assert actual_result[index] == expected_result[index]
-
-    def test_walk_topdown(self):
-        # Preparation: build tree in directory `walk_test`.
-        expected_result = [
-          ("walk_test",
-           ["dir1", "dir2", "dir3"],
-           ["file4"]),
-          #
-          ("walk_test/dir1",
-           ["dir11", "dir12"],
-           []),
-          #
-          ("walk_test/dir1/dir11",
-           [],
-           []),
-          #
-          ("walk_test/dir1/dir12",
-           ["dir123"],
-           ["file121", "file122"]),
-          #
-          ("walk_test/dir1/dir12/dir123",
-           [],
-           ["file1234"]),
-          #
-          ("walk_test/dir2",
-           [],
-           []),
-          #
-          ("walk_test/dir3",
-           ["dir31", "dir32"],
-           ["file31", "file32"]),
-          #
-          ("walk_test/dir3/dir31",
-           [],
-           []),
-          ]
-        self._walk_test(expected_result, top="walk_test")
-
-    def test_walk_depth_first(self):
-        # Preparation: build tree in directory `walk_test`
-        expected_result = [
-          ("walk_test/dir1/dir11",
-           [],
-           []),
-          #
-          ("walk_test/dir1/dir12/dir123",
-           [],
-           ["file1234"]),
-          #
-          ("walk_test/dir1/dir12",
-           ["dir123"],
-           ["file121", "file122"]),
-          #
-          ("walk_test/dir1",
-           ["dir11", "dir12"],
-           []),
-          #
-          ("walk_test/dir2",
-           [],
-           []),
-          #
-          ("walk_test/dir3/dir31",
-           [],
-           []),
-          #
-          ("walk_test/dir3",
-           ["dir31", "dir32"],
-           ["file31", "file32"]),
-          #
-          ("walk_test",
-           ["dir1", "dir2", "dir3"],
-           ["file4"])
-          ]
-        self._walk_test(expected_result, top="walk_test", topdown=False)
-
-    def test_walk_following_links(self):
-        # Preparation: build tree in directory `walk_test`.
-        expected_result = [
-          ("walk_test",
-           ["dir1", "dir2", "dir3"],
-           ["file4"]),
-          #
-          ("walk_test/dir1",
-           ["dir11", "dir12"],
-           []),
-          #
-          ("walk_test/dir1/dir11",
-           [],
-           []),
-          #
-          ("walk_test/dir1/dir12",
-           ["dir123"],
-           ["file121", "file122"]),
-          #
-          ("walk_test/dir1/dir12/dir123",
-           [],
-           ["file1234"]),
-          #
-          ("walk_test/dir2",
-           [],
-           []),
-          #
-          ("walk_test/dir3",
-           ["dir31", "dir32"],
-           ["file31", "file32"]),
-          #
-          ("walk_test/dir3/dir31",
-           [],
-           []),
-          #
-          ("walk_test/dir3/dir32",
-           [],
-           ["file1234"]),
-          ]
-        self._walk_test(expected_result, top="walk_test", followlinks=True)
-
-
-class TestRename(RealFTPTest):
-
-    def test_rename(self):
-        host = self.host
-        # Make sure the target of the renaming operation is removed.
-        self.cleaner.add_file("_testfile2_")
-        self.make_remote_file("_testfile1_")
-        host.rename("_testfile1_", "_testfile2_")
-        assert not host.path.exists("_testfile1_")
-        assert host.path.exists("_testfile2_")
-
-    def test_rename_with_spaces_in_directory(self):
-        host = self.host
-        dir_name = "_dir with spaces_"
-        self.cleaner.add_dir(dir_name)
-        host.mkdir(dir_name)
-        self.make_remote_file(dir_name + "/testfile1")
-        host.rename(dir_name + "/testfile1", dir_name + "/testfile2")
-        assert not host.path.exists(dir_name + "/testfile1")
-        assert host.path.exists(dir_name + "/testfile2")
-
-
-class TestStat(RealFTPTest):
-
-    def test_stat(self):
-        host = self.host
-        dir_name = "_testdir_"
-        file_name = host.path.join(dir_name, "_nonempty_")
-        # Make a directory and a file in it.
-        self.cleaner.add_dir(dir_name)
-        host.mkdir(dir_name)
-        with host.open(file_name, "wb") as fobj:
-            fobj.write(b"abc\x12\x34def\t")
-        # Do some stats
-        # - dir
-        dir_stat = host.stat(dir_name)
-        assert isinstance(dir_stat._st_name, ftputil.compat.unicode_type)
-        assert host.listdir(dir_name) == ["_nonempty_"]
-        assert host.path.isdir(dir_name)
-        assert not host.path.isfile(dir_name)
-        assert not host.path.islink(dir_name)
-        # - file
-        file_stat = host.stat(file_name)
-        assert isinstance(file_stat._st_name, ftputil.compat.unicode_type)
-        assert not host.path.isdir(file_name)
-        assert host.path.isfile(file_name)
-        assert not host.path.islink(file_name)
-        assert host.path.getsize(file_name) == 9
-        # - file's modification time; allow up to two minutes difference
-        host.synchronize_times()
-        server_mtime = host.path.getmtime(file_name)
-        client_mtime = time.mktime(time.localtime())
-        calculated_time_shift = server_mtime - client_mtime
-        assert not abs(calculated_time_shift-host.time_shift()) > 120
-
-    def test_issomething_for_nonexistent_directory(self):
-        host = self.host
-        # Check if we get the right results if even the containing
-        # directory doesn't exist (see ticket #66).
-        nonexistent_path = "/nonexistent/nonexistent"
-        assert not host.path.isdir(nonexistent_path)
-        assert not host.path.isfile(nonexistent_path)
-        assert not host.path.islink(nonexistent_path)
-
-    def test_special_broken_link(self):
-        # Test for ticket #39.
-        host = self.host
-        broken_link_name = os.path.join("dir_with_broken_link", "nonexistent")
-        assert (host.lstat(broken_link_name)._st_target ==
-                "../nonexistent/nonexistent")
-        assert not host.path.isdir(broken_link_name)
-        assert not host.path.isfile(broken_link_name)
-        assert host.path.islink(broken_link_name)
-
-    def test_concurrent_access(self):
-        self.make_remote_file("_testfile_")
-        with ftputil.FTPHost(*self.login_data) as host1:
-            with ftputil.FTPHost(*self.login_data) as host2:
-                stat_result1 = host1.stat("_testfile_")
-                stat_result2 = host2.stat("_testfile_")
-                assert stat_result1 == stat_result2
-                host2.remove("_testfile_")
-                # Can still get the result via `host1`
-                stat_result1 = host1.stat("_testfile_")
-                assert stat_result1 == stat_result2
-                # Stat'ing on `host2` gives an exception.
-                with pytest.raises(ftputil.error.PermanentError):
-                    host2.stat("_testfile_")
-                # Stat'ing on `host1` after invalidation
-                absolute_path = host1.path.join(host1.getcwd(), "_testfile_")
-                host1.stat_cache.invalidate(absolute_path)
-                with pytest.raises(ftputil.error.PermanentError):
-                    host1.stat("_testfile_")
-
-    def test_cache_auto_resizing(self):
-        """Test if the cache is resized appropriately."""
-        host = self.host
-        cache = host.stat_cache._cache
-        # Make sure the cache size isn't adjusted towards smaller values.
-        unused_entries = host.listdir("walk_test")
-        assert cache.size == ftputil.stat_cache.StatCache._DEFAULT_CACHE_SIZE
-        # Make the cache very small initially and see if it gets resized.
-        cache.size = 2
-        entries = host.listdir("walk_test")
-        # The adjusted cache size should be larger or equal to the
-        # number of items in `walk_test` and its parent directory. The
-        # latter is read implicitly upon `listdir`'s `isdir` call.
-        expected_min_cache_size = max(len(host.listdir(host.curdir)),
-                                      len(entries))
-        assert cache.size >= expected_min_cache_size
-
-
-class TestUploadAndDownload(RealFTPTest):
-    """Test upload and download (including time shift test)."""
-
-    def test_time_shift(self):
-        self.host.synchronize_times()
-        assert self.host.time_shift() == EXPECTED_TIME_SHIFT
-
-    @pytest.mark.slow_test
-    def test_upload(self):
-        host = self.host
-        host.synchronize_times()
-        local_file = "_local_file_"
-        remote_file = "_remote_file_"
-        # Make local file to upload.
-        self.make_local_file()
-        # Wait, else small time differences between client and server
-        # actually could trigger the update.
-        time.sleep(65)
-        try:
-            self.cleaner.add_file(remote_file)
-            host.upload(local_file, remote_file)
-            # Retry; shouldn't be uploaded
-            uploaded = host.upload_if_newer(local_file, remote_file)
-            assert uploaded is False
-            # Rewrite the local file.
-            self.make_local_file()
-            # Retry; should be uploaded now
-            uploaded = host.upload_if_newer(local_file, remote_file)
-            assert uploaded is True
-        finally:
-            # Clean up
-            os.unlink(local_file)
-
-    @pytest.mark.slow_test
-    def test_download(self):
-        host = self.host
-        host.synchronize_times()
-        local_file = "_local_file_"
-        remote_file = "_remote_file_"
-        # Make a remote file.
-        self.make_remote_file(remote_file)
-        # File should be downloaded as it's not present yet.
-        downloaded = host.download_if_newer(remote_file, local_file)
-        assert downloaded is True
-        try:
-            # If the remote file, taking the datetime precision into
-            # account, _might_ be newer, the file will be downloaded
-            # again. To prevent this, wait a bit over a minute (the
-            # remote precision), then "touch" the local file.
-            time.sleep(65)
-            # Create empty file.
-            with open(local_file, "w") as fobj:
-                pass
-            # Local file is present and newer, so shouldn't download.
-            downloaded = host.download_if_newer(remote_file, local_file)
-            assert downloaded is False
-            # Re-make the remote file.
-            self.make_remote_file(remote_file)
-            # Local file is present but possibly older (taking the
-            # possible deviation because of the precision into account),
-            # so should download.
-            downloaded = host.download_if_newer(remote_file, local_file)
-            assert downloaded is True
-        finally:
-            # Clean up.
-            os.unlink(local_file)
-
-    def test_callback_with_transfer(self):
-        host = self.host
-        FILE_NAME = "debian-keyring.tar.gz"
-        # Default chunk size as in `FTPHost.copyfileobj`
-        MAX_COPY_CHUNK_SIZE = ftputil.file_transfer.MAX_COPY_CHUNK_SIZE
-        file_size = host.path.getsize(FILE_NAME)
-        chunk_count, _ = divmod(file_size, MAX_COPY_CHUNK_SIZE)
-        # Add one chunk for remainder.
-        chunk_count += 1
-        # Define a callback that just collects all data passed to it.
-        transferred_chunks_list = []
-        def test_callback(chunk):
-            transferred_chunks_list.append(chunk)
-        try:
-            host.download(FILE_NAME, FILE_NAME, callback=test_callback)
-            # Construct a list of data chunks we expect.
-            expected_chunks_list = []
-            with open(FILE_NAME, "rb") as downloaded_fobj:
-                while True:
-                    chunk = downloaded_fobj.read(MAX_COPY_CHUNK_SIZE)
-                    if not chunk:
-                        break
-                    expected_chunks_list.append(chunk)
-            # Examine data collected by callback function.
-            assert len(transferred_chunks_list) == chunk_count
-            assert transferred_chunks_list == expected_chunks_list
-        finally:
-            os.unlink(FILE_NAME)
-
-
-class TestFTPFiles(RealFTPTest):
-
-    def test_only_closed_children(self):
-        REMOTE_FILE_NAME = "CONTENTS"
-        host = self.host
-        with host.open(REMOTE_FILE_NAME, "rb") as file_obj1:
-            # Create empty file and close it.
-            with host.open(REMOTE_FILE_NAME, "rb") as file_obj2:
-                pass
-            # This should re-use the second child because the first isn't
-            # closed but the second is.
-            with host.open(REMOTE_FILE_NAME, "rb") as file_obj:
-                assert len(host._children) == 2
-                assert file_obj._host is host._children[1]
-
-    def test_no_timed_out_children(self):
-        REMOTE_FILE_NAME = "CONTENTS"
-        host = self.host
-        # Implicitly create child host object.
-        with host.open(REMOTE_FILE_NAME, "rb") as file_obj1:
-            pass
-        # Monkey-patch file to simulate an FTP server timeout below.
-        def timed_out_pwd():
-            raise ftplib.error_temp("simulated timeout")
-        file_obj1._host._session.pwd = timed_out_pwd
-        # Try to get a file - which shouldn't be the timed-out file.
-        with host.open(REMOTE_FILE_NAME, "rb") as file_obj2:
-            assert file_obj1 is not file_obj2
-        # Re-use closed and not timed-out child session.
-        with host.open(REMOTE_FILE_NAME, "rb") as file_obj3:
-            pass
-        assert file_obj2 is file_obj3
-
-    def test_no_delayed_226_children(self):
         REMOTE_FILE_NAME = "CONTENTS"
         host = self.host
         # Implicitly create child host object.
@@ -722,267 +117,3 @@
             pass
         assert file_obj2 is file_obj3
 
-
-class TestChmod(RealFTPTest):
-
-    def assert_mode(self, path, expected_mode):
-        """
-        Return an integer containing the allowed bits in the mode
-        change command.
-
-        The `FTPHost` object to test against is `self.host`.
-        """
-        full_mode = self.host.stat(path).st_mode
-        # Remove flags we can't set via `chmod`.
-        # Allowed flags according to Python documentation
-        # https://docs.python.org/library/stat.html
-        allowed_flags = [stat.S_ISUID, stat.S_ISGID, stat.S_ENFMT,
-          stat.S_ISVTX, stat.S_IREAD, stat.S_IWRITE, stat.S_IEXEC,
-          stat.S_IRWXU, stat.S_IRUSR, stat.S_IWUSR, stat.S_IXUSR,
-          stat.S_IRWXG, stat.S_IRGRP, stat.S_IWGRP, stat.S_IXGRP,
-          stat.S_IRWXO, stat.S_IROTH, stat.S_IWOTH, stat.S_IXOTH]
-        allowed_mask = functools.reduce(operator.or_, allowed_flags)
-        mode = full_mode & allowed_mask
-        assert mode == expected_mode, (
-                 "mode {0:o} != {1:o}".format(mode, expected_mode))
-
-    def test_chmod_existing_directory(self):
-        host = self.host
-        host.mkdir("_test dir_")
-        self.cleaner.add_dir("_test dir_")
-        # Set/get mode of a directory.
-        host.chmod("_test dir_", 0o757)
-        self.assert_mode("_test dir_", 0o757)
-        # Set/get mode in nested directory.
-        host.mkdir("_test dir_/nested_dir")
-        self.cleaner.add_dir("_test dir_/nested_dir")
-        host.chmod("_test dir_/nested_dir", 0o757)
-        self.assert_mode("_test dir_/nested_dir", 0o757)
-
-    def test_chmod_existing_file(self):
-        host = self.host
-        host.mkdir("_test dir_")
-        self.cleaner.add_dir("_test dir_")
-        # Set/get mode on a file.
-        file_name = host.path.join("_test dir_", "_testfile_")
-        self.make_remote_file(file_name)
-        host.chmod(file_name, 0o646)
-        self.assert_mode(file_name, 0o646)
-
-    def test_chmod_nonexistent_path(self):
-        # Set/get mode of a non-existing item.
-        with pytest.raises(ftputil.error.PermanentError):
-            self.host.chmod("nonexistent", 0o757)
-
-    def test_cache_invalidation(self):
-        host = self.host
-        host.mkdir("_test dir_")
-        self.cleaner.add_dir("_test dir_")
-        # Make sure the mode is in the cache.
-        unused_stat_result = host.stat("_test dir_")
-        # Set/get mode of the directory.
-        host.chmod("_test dir_", 0o757)
-        self.assert_mode("_test dir_", 0o757)
-        # Set/get mode on a file.
-        file_name = host.path.join("_test dir_", "_testfile_")
-        self.make_remote_file(file_name)
-        # Make sure the mode is in the cache.
-        unused_stat_result = host.stat(file_name)
-        host.chmod(file_name, 0o646)
-        self.assert_mode(file_name, 0o646)
-
-
-class TestRestArgument(RealFTPTest):
-
-    TEST_FILE_NAME = "rest_test"
-
-    def setup_method(self, method):
-        super(TestRestArgument, self).setup_method(method)
-        # Write test file.
-        with self.host.open(self.TEST_FILE_NAME, "wb") as fobj:
-            fobj.write(b"abcdefghijkl")
-        self.cleaner.add_file(self.TEST_FILE_NAME)
-
-    def test_for_reading(self):
-        """
-        If a `rest` argument is passed to `open`, the following read
-        operation should start at the byte given by `rest`.
-        """
-        with self.host.open(self.TEST_FILE_NAME, "rb", rest=3) as fobj:
-            data = fobj.read()
-        assert data == b"defghijkl"
-
-    def test_for_writing(self):
-        """
-        If a `rest` argument is passed to `open`, the following write
-        operation should start writing at the byte given by `rest`.
-        """
-        with self.host.open(self.TEST_FILE_NAME, "wb", rest=3) as fobj:
-            fobj.write(b"123")
-        with self.host.open(self.TEST_FILE_NAME, "rb") as fobj:
-            data = fobj.read()
-        assert data == b"abc123"
-
-    def test_invalid_read_from_text_file(self):
-        """
-        If the `rest` argument is used for reading from a text file,
-        a `CommandNotImplementedError` should be raised.
-        """
-        with pytest.raises(ftputil.error.CommandNotImplementedError):
-            self.host.open(self.TEST_FILE_NAME, "r", rest=3)
-
-    def test_invalid_write_to_text_file(self):
-        """
-        If the `rest` argument is used for reading from a text file,
-        a `CommandNotImplementedError` should be raised.
-        """
-        with pytest.raises(ftputil.error.CommandNotImplementedError):
-            self.host.open(self.TEST_FILE_NAME, "w", rest=3)
-
-    # There are no tests for reading and writing beyond the end of a
-    # file. For example, if the remote file is 10 bytes long and
-    # `open(remote_file, "rb", rest=100)` is used, the server may
-    # return an error status code or not.
-    #
-    # The server I use for testing returns a 554 status when
-    # attempting to _read_ beyond the end of the file. On the other
-    # hand, if attempting to _write_ beyond the end of the file, the
-    # server accepts the request, but starts writing after the end of
-    # the file, i. e. appends to the file.
-    #
-    # Instead of expecting certain responses that may differ between
-    # server implementations, I leave the bahavior for too large
-    # `rest` arguments undefined. In practice, this shouldn't be a
-    # problem because the `rest` argument should only be used for
-    # error recovery, and in this case a valid byte count for the
-    # `rest` argument should be known.
-
-
-class TestOther(RealFTPTest):
-
-    def test_open_for_reading(self):
-        # Test for issues #17 and #51,
-        # http://ftputil.sschwarzer.net/trac/ticket/17 and
-        # http://ftputil.sschwarzer.net/trac/ticket/51 .
-        file1 = self.host.open("debian-keyring.tar.gz", "rb")
-        time.sleep(1)
-        # Depending on the FTP server, this might return a status code
-        # unexpected by `ftplib` or block the socket connection until
-        # a server-side timeout.
-        file1.close()
-
-    def test_subsequent_reading(self):
-        # Open a file for reading.
-        with self.host.open("CONTENTS", "rb") as file1:
-            pass
-        # Make sure that there are no problems if the connection is reused.
-        with self.host.open("CONTENTS", "rb") as file2:
-            pass
-        assert file1._session is file2._session
-
-    def test_names_with_spaces(self):
-        # Test if directories and files with spaces in their names
-        # can be used.
-        host = self.host
-        assert host.path.isdir("dir with spaces")
-        assert (host.listdir("dir with spaces") ==
-                ["second dir", "some file", "some_file"])
-        assert host.path.isdir("dir with spaces/second dir")
-        assert host.path.isfile("dir with spaces/some_file")
-        assert host.path.isfile("dir with spaces/some file")
-
-    def test_synchronize_times_without_write_access(self):
-        """Test failing synchronization because of non-writable directory."""
-        host = self.host
-        # This isn't writable by the ftp account the tests are run under.
-        host.chdir("rootdir1")
-        with pytest.raises(ftputil.error.TimeShiftError):
-            host.synchronize_times()
-
-    def test_listdir_with_non_ascii_byte_string(self):
-        """
-        `listdir` should accept byte strings with non-ASCII
-        characters and return non-ASCII characters in directory or
-        file names.
-        """
-        host = self.host
-        path = "äbc".encode("UTF-8")
-        names = host.listdir(path)
-        assert names[0] == b"file1"
-        assert names[1] == "file1_ö".encode("UTF-8")
-
-    def test_listdir_with_non_ascii_unicode_string(self):
-        """
-        `listdir` should accept unicode strings with non-ASCII
-        characters and return non-ASCII characters in directory or
-        file names.
-        """
-        host = self.host
-        # `ftplib` under Python 3 only works correctly if the unicode
-        # strings are decoded from latin1. Under Python 2, ftputil
-        # is supposed to provide a compatible interface.
-        path = "äbc".encode("UTF-8").decode("latin1")
-        names = host.listdir(path)
-        assert names[0] == "file1"
-        assert names[1] == "file1_ö".encode("UTF-8").decode("latin1")
-
-    def test_path_with_non_latin1_unicode_string(self):
-        """
-        ftputil operations shouldn't accept file paths with non-latin1
-        characters.
-        """
-        # Use some musical symbols. These are certainly not latin1.
-        path = "𝄞𝄢"
-        # `UnicodeEncodeError` is also the exception that `ftplib`
-        # raises if it gets a non-latin1 path.
-        with pytest.raises(UnicodeEncodeError):
-            self.host.mkdir(path)
-
-    def test_list_a_option(self):
-        # For this test to pass, the server must _not_ list "hidden"
-        # files by default but instead only when the `LIST` `-a`
-        # option is used.
-        host = self.host
-        assert host.use_list_a_option
-        directory_entries = host.listdir(host.curdir)
-        assert ".hidden" in directory_entries
-        host.use_list_a_option = False
-        directory_entries = host.listdir(host.curdir)
-        assert ".hidden" not in directory_entries
-
-    def _make_objects_to_be_garbage_collected(self):
-        for _ in range(10):
-            with ftputil.FTPHost(*self.login_data) as host:
-                for _ in range(10):
-                    unused_stat_result = host.stat("CONTENTS")
-                    with host.open("CONTENTS") as fobj:
-                        unused_data = fobj.read()
-
-    def test_garbage_collection(self):
-        """Test whether there are cycles which prevent garbage collection."""
-        gc.collect()
-        objects_before_test = len(gc.garbage)
-        self._make_objects_to_be_garbage_collected()
-        gc.collect()
-        objects_after_test = len(gc.garbage)
-        assert not objects_after_test - objects_before_test
-
-    @pytest.mark.skipif(
-      ftputil.compat.python_version > 2,
-      reason="test requires M2Crypto which only works on Python 2")
-    def test_m2crypto_session(self):
-        """
-        Test if a session with `M2Crypto.ftpslib.FTP_TLS` is set up
-        correctly and works with unicode input.
-        """
-        # See ticket #78.
-        #
-        # M2Crypto is only available for Python 2.
-        import M2Crypto
-        factory = ftputil.session.session_factory(
-                    base_class=M2Crypto.ftpslib.FTP_TLS,
-                    encrypt_data_channel=True)
-        with ftputil.FTPHost(*self.login_data, session_factory=factory) as host:
-            # Test if unicode argument works.
-            files = host.listdir(".")
-        assert "CONTENTS" in files
--- a/test/test_public_servers.py
+++ b/test/test_public_servers.py
@@ -75,104 +75,3 @@
     return names
 
 
-class TestPublicServers(object):
-    """
-    Get directory listings from various public FTP servers
-    with a command line client and ftputil and compare both.
-
-    An important aspect is to test different "spellings" of
-    the same directory. For example, to list the root directory
-    which is usually set after login, use "" (nothing), ".",
-    "/", "/.", "./.", "././", "..", "../.", "../.." etc.
-
-    The command line client `ftp` has to be in the path.
-    """
-
-    # Implementation note:
-    #
-    # I (Stefan) implement the code so it works with Ubuntu's
-    # client. Other clients may work or not. If you have problems
-    # testing some other client, please send me a (small) patch.
-    # Keep in mind that I don't plan supporting as many FTP
-    # obscure commandline clients as servers. ;-)
-
-    # List of pairs with server name and a directory "guaranteed
-    # to exist" under the login directory which is assumed to be
-    # the root directory.
-    servers = [# Posix format
-               ("ftp.de.debian.org", "debian"),
-               ("ftp.gnome.org",  "pub"),
-               ("ftp.heanet.ie",  "pub"),
-               ("ftp.heise.de",   "pub"),
-               # DOS/Microsoft format
-               # Do you know any FTP servers that use Microsoft
-               # format? `ftp.microsoft.com` doesn't seem to be
-               # reachable anymore.
-              ]
-
-    # This data structure contains the initial directories "." and
-    # "DIR" (which will be replaced by a valid directory name for
-    # each server). The list after the initial directory contains
-    # paths that will be queried after changing into the initial
-    # directory. All items in these lists are actually supposed to
-    # yield the same directory contents.
-    paths_table = [
-      (".", ["", ".", "/", "/.", "./.", "././", "..", "../.", "../..",
-             "DIR/..", "/DIR/../.", "/DIR/../.."]),
-      ("DIR", ["", ".", "/DIR", "/DIR/", "../DIR", "../../DIR"])
-      ]
-
-    def inner_test_server(self, server, initial_directory, paths):
-        """
-        Test one server for one initial directory.
-
-        Connect to the server `server`; if the string argument
-        `initial_directory` has a true value, change to this
-        directory. Then iterate over all strings in the sequence
-        `paths`, comparing the results of a listdir call with the
-        listing from the command line client.
-        """
-        canonical_names = ftp_client_listing(server, initial_directory)
-        host = ftputil.FTPHost(server, "anonymous", EMAIL)
-        try:
-            host.chdir(initial_directory)
-            for path in paths:
-                path = path.replace("DIR", initial_directory)
-                # Make sure that we don't recycle directory entries, i. e.
-                # really repeatedly retrieve the directory contents
-                # (shouldn't happen anyway with the current implementation).
-                host.stat_cache.clear()
-                names = host.listdir(path)
-                # Filter out "hidden" names since the FTP command line
-                # client won't include them in its listing either.
-                names = [name for name in names
-                              if not (
-                                name.startswith(".") or
-                                # The login directory of `ftp.microsoft.com`
-                                # contains this "hidden" entry that ftputil
-                                # finds but not the FTP command line client.
-                                name == "mscomtest"
-                              )]
-                failure_message = ("For server {0}, directory {1}: {2} != {3}".
-                                   format(server, initial_directory, names,
-                                          canonical_names))
-                assert names == canonical_names, failure_message
-        finally:
-            host.close()
-
-    @pytest.mark.slow_test
-    def test_servers(self):
-        """
-        Test all servers in `self.servers`.
-
-        For each server, get the listings for the login directory and
-        one other directory which is known to exist. Use different
-        "spellings" to retrieve each list via ftputil and compare with
-        the results gotten with the command line client.
-        """
-        for server, actual_initial_directory in self.servers:
-            for initial_directory, paths in self.paths_table:
-                initial_directory = initial_directory.replace(
-                                      "DIR", actual_initial_directory)
-                print(server, initial_directory)
-                self.inner_test_server(server, initial_directory, paths)
--- a/test/test_host.py
+++ b/test/test_host.py
@@ -499,8 +499,8 @@
         """Test whether `upload` accepts either unicode or bytes."""
         host = self.host
         # The source file needs to be present in the current directory.
-        host.upload("Makefile", "target")
-        host.upload("Makefile", ftputil.tool.as_bytes("target"))
+        host.upload("ftputil/path.py", "target")
+        host.upload("ftputil/path.py", ftputil.tool.as_bytes("target"))
 
     def test_download(self):
         """Test whether `download` accepts either unicode or bytes."""
--- a/test/test_stat.py
+++ b/test/test_stat.py
@@ -364,24 +364,6 @@
         self.stat = \
           _test_stat(session_factory=mock_ftplib.MockUnixFormatSession)
 
-    def test_repr(self):
-        """Test if the `repr` result looks like a named tuple."""
-        stat_result = self.stat._lstat("/home/sschwarzer/chemeng")
-        # Only under Python 2, unicode strings have the `u` prefix.
-        # TODO: Make the value for `st_mtime` robust against DST "time
-        # zone" changes.
-        if ftputil.compat.python_version == 2:
-            expected_result = (
-              b"StatResult(st_mode=17901, st_ino=None, st_dev=None, "
-              b"st_nlink=2, st_uid=u'45854', st_gid=u'200', st_size=512, "
-              b"st_atime=None, st_mtime=957391200.0, st_ctime=None)")
-        else:
-            expected_result = (
-              "StatResult(st_mode=17901, st_ino=None, st_dev=None, "
-              "st_nlink=2, st_uid='45854', st_gid='200', st_size=512, "
-              "st_atime=None, st_mtime=957391200.0, st_ctime=None)")
-        assert repr(stat_result) == expected_result
-
     def test_failing_lstat(self):
         """Test whether `lstat` fails for a nonexistent path."""
         with pytest.raises(ftputil.error.PermanentError):
--- a/setup.py
+++ b/setup.py
@@ -39,7 +39,6 @@
   version=_version,
   packages=[_package],
   package_dir={_package: _package},
-  data_files=[("doc/ftputil", doc_files)],
   # Metadata
   author="Stefan Schwarzer",
   author_email="sschwarzer@sschwarzer.net",