Changeset 1833:cc9e84b0a418


Ignore:
Timestamp:
Jul 10, 2019, 9:42:29 PM (3 months ago)
Author:
Stefan Schwarzer <sschwarzer@…>
Branch:
default
amend_source:
30244b816dfeca47d81cd6b3ef9f2b4806f8e785
Message:
Use `ScriptedSession` in `TestAcceptEitherBytesOrUnicode`
File:
1 edited

Legend:

Unmodified
Added
Removed
  • test/test_path.py

    r1832 r1833  
    1313import ftputil.tool
    1414
    15 from test import mock_ftplib
    1615from test import test_base
    1716from test import scripted_session
     
    367366class TestAcceptEitherBytesOrUnicode:
    368367
    369     def setup_method(self, method):
    370         self.host = test_base.ftp_host_factory()
    371 
    372368    def _test_method_string_types(self, method, path):
    373369        expected_type = type(path)
     
    378374        Test whether the same string type as for the argument is returned.
    379375        """
    380         method_names = ("abspath basename dirname join normcase normpath".
    381                         split())
    382         for method_name in method_names:
    383             method = getattr(self.host.path, method_name)
    384             self._test_method_string_types(method, "/")
    385             self._test_method_string_types(method, ".")
    386             self._test_method_string_types(method, b"/")
    387             self._test_method_string_types(method, b".")
     376        method_names = ["abspath", "basename", "dirname", "join", "normcase",
     377                        "normpath"]
     378        script = [
     379          Call("__init__"),
     380          Call("pwd", result="/"),
     381          Call("close")
     382        ]
     383        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     384            for method_name in method_names:
     385                method = getattr(host.path, method_name)
     386                self._test_method_string_types(method, "/")
     387                self._test_method_string_types(method, ".")
     388                self._test_method_string_types(method, b"/")
     389                self._test_method_string_types(method, b".")
    388390
    389391    def test_methods_that_take_a_string_and_return_a_bool(self):
    390392        """Test whether the methods accept byte and unicode strings."""
    391         host = self.host
    392393        as_bytes = ftputil.tool.as_bytes
    393         host.chdir("/home/file_name_test")
    394         # `isabs`
    395         assert not host.path.isabs("ä")
    396         assert not host.path.isabs(as_bytes("ä"))
    397         # `exists`
    398         assert host.path.exists("ä")
    399         assert host.path.exists(as_bytes("ä"))
    400         # `isdir`, `isfile`, `islink`
    401         assert host.path.isdir("ä")
    402         assert host.path.isdir(as_bytes("ä"))
    403         assert host.path.isfile("ö")
    404         assert host.path.isfile(as_bytes("ö"))
    405         assert host.path.islink("ü")
    406         assert host.path.islink(as_bytes("ü"))
     394        script = [
     395          Call("__init__"),
     396          Call("pwd", result="/"),
     397          # `exists` test 1
     398          Call("cwd", args=("/",)),
     399          Call("cwd", args=("/",)),
     400          Call("dir",
     401               args=("",),
     402               result=test_base.dir_line(name="ä",
     403                                         datetime_=datetime.datetime.now())),
     404          Call("cwd", args=("/",)),
     405          # `exists` test 2
     406          Call("cwd", args=("/",)),
     407          Call("cwd", args=("/",)),
     408          Call("dir",
     409               args=("",),
     410               result=test_base.dir_line(name="ä",
     411                                         datetime_=datetime.datetime.now())),
     412          Call("cwd", args=("/",)),
     413          # `isdir` test 1
     414          Call("cwd", args=("/",)),
     415          Call("cwd", args=("/",)),
     416          Call("dir",
     417               args=("",),
     418               result=test_base.dir_line(mode_string="dr-xr-xr-x",
     419                                         name="ä",
     420                                         datetime_=datetime.datetime.now())),
     421          Call("cwd", args=("/",)),
     422          # `isdir` test 2
     423          Call("cwd", args=("/",)),
     424          Call("cwd", args=("/",)),
     425          Call("dir",
     426               args=("",),
     427               result=test_base.dir_line(mode_string="dr-xr-xr-x",
     428                                         name="ä",
     429                                         datetime_=datetime.datetime.now())),
     430          Call("cwd", args=("/",)),
     431          # `isfile` test 1
     432          Call("cwd", args=("/",)),
     433          Call("cwd", args=("/",)),
     434          Call("dir",
     435               args=("",),
     436               result=test_base.dir_line(name="ö",
     437                                         datetime_=datetime.datetime.now())),
     438          Call("cwd", args=("/",)),
     439          # `isfile` test 2
     440          Call("cwd", args=("/",)),
     441          Call("cwd", args=("/",)),
     442          Call("dir",
     443               args=("",),
     444               result=test_base.dir_line(name="ö",
     445                                         datetime_=datetime.datetime.now())),
     446          Call("cwd", args=("/",)),
     447          # `islink` test 1
     448          Call("cwd", args=("/",)),
     449          Call("cwd", args=("/",)),
     450          Call("dir",
     451               args=("",),
     452               result=test_base.dir_line(mode_string="lrwxrwxrwx",
     453                                         name="ü",
     454                                         datetime_=datetime.datetime.now(),
     455                                         link_target="unimportant")),
     456          Call("cwd", args=("/",)),
     457          # `islink` test 2
     458          Call("cwd", args=("/",)),
     459          Call("cwd", args=("/",)),
     460          Call("dir",
     461               args=("",),
     462               result=test_base.dir_line(mode_string="lrwxrwxrwx",
     463                                         name="ü",
     464                                         datetime_=datetime.datetime.now(),
     465                                         link_target="unimportant")),
     466          Call("cwd", args=("/",)),
     467          Call("close")
     468        ]
     469        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     470            host.stat_cache.disable()
     471            # `isabs`
     472            assert not host.path.isabs("ä")
     473            assert not host.path.isabs(as_bytes("ä"))
     474            # `exists`
     475            assert host.path.exists("ä")
     476            assert host.path.exists(as_bytes("ä"))
     477            # `isdir`, `isfile`, `islink`
     478            assert host.path.isdir("ä")
     479            assert host.path.isdir(as_bytes("ä"))
     480            assert host.path.isfile("ö")
     481            assert host.path.isfile(as_bytes("ö"))
     482            assert host.path.islink("ü")
     483            assert host.path.islink(as_bytes("ü"))
    407484
    408485    def test_join(self):
     
    411488        the same string type and returns the same string type.
    412489        """
    413         join = self.host.path.join
    414490        as_bytes = ftputil.tool.as_bytes
    415         # Only unicode
    416         parts = list("äöü")
    417         result = join(*parts)
    418         assert result == "ä/ö/ü"
    419         # Only bytes
    420         parts = [as_bytes(s) for s in "äöü"]
    421         result = join(*parts)
    422         assert result == as_bytes("ä/ö/ü")
    423         # Mixture of unicode and bytes
    424         parts = ["ä", as_bytes("ö")]
    425         with pytest.raises(TypeError):
    426             join(*parts)
    427         parts = [as_bytes("ä"), as_bytes("ö"), "ü"]
    428         with pytest.raises(TypeError):
    429             join(*parts)
     491        script = [
     492          Call("__init__"),
     493          Call("pwd", result="/"),
     494          Call("close")
     495        ]
     496        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     497            host.stat_cache.disable()
     498            join = host.path.join
     499            # Only unicode
     500            parts = ["ä", "ö", "ü"]
     501            result = join(*parts)
     502            assert result == "ä/ö/ü"
     503            # Only bytes
     504            parts = [as_bytes(s) for s in parts]
     505            result = join(*parts)
     506            assert result == as_bytes("ä/ö/ü")
     507            # Mixture of unicode and bytes
     508            parts = ["ä", as_bytes("ö")]
     509            with pytest.raises(TypeError):
     510                join(*parts)
     511            parts = [as_bytes("ä"), as_bytes("ö"), "ü"]
     512            with pytest.raises(TypeError):
     513                join(*parts)
    430514
    431515    def test_getmtime(self):
     
    434518        paths.
    435519        """
    436         host = self.host
    437520        as_bytes = ftputil.tool.as_bytes
    438         host.chdir("/home/file_name_test")
    439         # We don't care about the _exact_ time, so don't bother with
    440         # timezone differences. Instead, do a simple sanity check.
    441         day = 24 * 60 * 60  # seconds
    442         expected_mtime = time.mktime((2000, 5, 29, 0, 0, 0, 0, 0, 0))
    443         mtime_makes_sense = (lambda mtime: expected_mtime - day <= mtime <=
    444                                            expected_mtime + day)
    445         assert mtime_makes_sense(host.path.getmtime("ä"))
    446         assert mtime_makes_sense(host.path.getmtime(as_bytes("ä")))
     521        now = datetime.datetime.now()
     522        script = [
     523          Call("__init__"),
     524          Call("pwd", result="/"),
     525          # `getmtime` call 1
     526          Call("cwd", args=("/",)),
     527          Call("cwd", args=("/",)),
     528          Call("dir",
     529               args=("",),
     530               result=test_base.dir_line(name="ä",
     531                                         datetime_=now)),
     532          Call("cwd", args=("/",)),
     533          # `getmtime` call 2
     534          Call("cwd", args=("/",)),
     535          Call("cwd", args=("/",)),
     536          Call("dir",
     537               args=("",),
     538               result=test_base.dir_line(name="ä",
     539                                         datetime_=now)),
     540          Call("cwd", args=("/",)),
     541          Call("close")
     542        ]
     543        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     544            host.stat_cache.disable()
     545            expected_mtime = now.timestamp()
     546            # We don't care about the _exact_ time, so don't bother with
     547            # timezone differences. Instead, do a simple sanity check.
     548            day = 24 * 60 * 60  # seconds
     549            mtime_makes_sense = (lambda mtime: expected_mtime - day <= mtime <=
     550                                               expected_mtime + day)
     551            assert mtime_makes_sense(host.path.getmtime("ä"))
     552            assert mtime_makes_sense(host.path.getmtime(as_bytes("ä")))
    447553
    448554    def test_getsize(self):
     
    450556        Test whether `FTPHost.path.getsize` accepts byte and unicode paths.
    451557        """
    452         host = self.host
    453558        as_bytes = ftputil.tool.as_bytes
    454         host.chdir("/home/file_name_test")
    455         assert host.path.getsize("ä") == 512
    456         assert host.path.getsize(as_bytes("ä")) == 512
     559        now = datetime.datetime.now()
     560        script = [
     561          Call("__init__"),
     562          Call("pwd", result="/"),
     563          # `getsize` call 1
     564          Call("cwd", args=("/",)),
     565          Call("cwd", args=("/",)),
     566          Call("dir",
     567               args=("",),
     568               result=test_base.dir_line(name="ä",
     569                                         size=512,
     570                                         datetime_=now)),
     571          Call("cwd", args=("/",)),
     572          # `getsize` call 2
     573          Call("cwd", args=("/",)),
     574          Call("cwd", args=("/",)),
     575          Call("dir",
     576               args=("",),
     577               result=test_base.dir_line(name="ä",
     578                                         size=512,
     579                                         datetime_=now)),
     580          Call("cwd", args=("/",)),
     581          Call("close")
     582        ]
     583        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     584            host.stat_cache.disable()
     585            assert host.path.getsize("ä") == 512
     586            assert host.path.getsize(as_bytes("ä")) == 512
    457587
    458588    def test_walk(self):
    459589        """Test whether `FTPHost.path.walk` accepts bytes and unicode paths."""
    460         host = self.host
    461590        as_bytes = ftputil.tool.as_bytes
     591        now = datetime.datetime.now()
     592        script = [
     593          Call("__init__"),
     594          Call("pwd", result="/"),
     595          # `walk` call 1
     596          Call("cwd", args=("/",)),
     597          Call("cwd", args=("/",)),
     598          Call("dir",
     599               args=("",),
     600               result=test_base.dir_line(mode_string="dr-xr-xr-x",
     601                                         name="ä",
     602                                         size=512,
     603                                         datetime_=now)),
     604          Call("cwd", args=("/",)),
     605          Call("cwd", args=("/",)),
     606          Call("cwd", args=("/ä",)),
     607          #  Assume directory `ä` is empty.
     608          Call("dir", args=("",), result=""),
     609          Call("cwd", args=("/",)),
     610          # `walk` call 2
     611          Call("cwd", args=("/",)),
     612          Call("cwd", args=("/",)),
     613          Call("dir",
     614               args=("",),
     615               result=test_base.dir_line(mode_string="dr-xr-xr-x",
     616                                         name="ä",
     617                                         size=512,
     618                                         datetime_=now)),
     619          Call("cwd", args=("/",)),
     620          Call("cwd", args=("/",)),
     621          Call("cwd", args=("/ä",)),
     622          #  Assume directory `ä` is empty.
     623          Call("dir", args=("",), result=""),
     624          Call("cwd", args=("/",)),
     625          Call("close")
     626        ]
    462627        def noop(arg, top, names):
    463628            del names[:]
    464         host.path.walk("ä", noop, None)
    465         host.path.walk(as_bytes("ä"), noop, None)
     629        with test_base.ftp_host_factory(scripted_session.factory(script)) as host:
     630            host.stat_cache.disable()
     631            host.path.walk("ä", func=noop, arg=None)
     632            host.path.walk(as_bytes("ä"), func=noop, arg=None)
Note: See TracChangeset for help on using the changeset viewer.