404

[ Avaa Bypassed ]




Upload:

Command:

botdev@3.144.251.23: ~ $
# -*- test-case-name: twisted.python.test.test_urlpath -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Tests for L{twisted.python.urlpath}.
"""

from twisted.trial import unittest
from twisted.python import urlpath
from twisted.python.compat import _PY3


class _BaseURLPathTests(object):
    """
    Tests for instantiated L{urlpath.URLPath}s.
    """
    def test_partsAreBytes(self):
        """
        All of the attributes of L{urlpath.URLPath} should be L{bytes}.
        """
        self.assertIsInstance(self.path.scheme, bytes)
        self.assertIsInstance(self.path.netloc, bytes)
        self.assertIsInstance(self.path.path, bytes)
        self.assertIsInstance(self.path.query, bytes)
        self.assertIsInstance(self.path.fragment, bytes)


    def test_strReturnsStr(self):
        """
        Calling C{str()} with a L{URLPath} will always return a L{str}.
        """
        self.assertEqual(type(self.path.__str__()), str)


    def test_mutabilityWithText(self, stringType=type(u"")):
        """
        Setting attributes on L{urlpath.URLPath} should change the value
        returned by L{str}.

        @param stringType: a callable to parameterize this test for different
            text types.
        @type stringType: 1-argument callable taking L{unicode} and returning
            L{str} or L{bytes}.
        """
        self.path.scheme = stringType(u"https")
        self.assertEqual(
            str(self.path),
            "https://example.com/foo/bar?yes=no&no=yes#footer")
        self.path.netloc = stringType(u"another.example.invalid")
        self.assertEqual(
            str(self.path),
            "https://another.example.invalid/foo/bar?yes=no&no=yes#footer")
        self.path.path = stringType(u"/hello")
        self.assertEqual(
            str(self.path),
            "https://another.example.invalid/hello?yes=no&no=yes#footer")
        self.path.query = stringType(u"alpha=omega&opposites=same")
        self.assertEqual(
            str(self.path),
            "https://another.example.invalid/hello?alpha=omega&opposites=same"
            "#footer")
        self.path.fragment = stringType(u"header")
        self.assertEqual(
            str(self.path),
            "https://another.example.invalid/hello?alpha=omega&opposites=same"
            "#header")


    def test_mutabilityWithBytes(self):
        """
        Same as L{test_mutabilityWithText} but for bytes.
        """
        self.test_mutabilityWithText(lambda x: x.encode("ascii"))


    def test_allAttributesAreBytes(self):
        """
        A created L{URLPath} has bytes attributes.
        """
        self.assertIsInstance(self.path.scheme, bytes)
        self.assertIsInstance(self.path.netloc, bytes)
        self.assertIsInstance(self.path.path, bytes)
        self.assertIsInstance(self.path.query, bytes)
        self.assertIsInstance(self.path.fragment, bytes)


    def test_stringConversion(self):
        """
        Calling C{str()} with a L{URLPath} will return the same URL that it was
        constructed with.
        """
        self.assertEqual(str(self.path),
                         "http://example.com/foo/bar?yes=no&no=yes#footer")


    def test_childString(self):
        """
        Calling C{str()} with a C{URLPath.child()} will return a URL which is
        the child of the URL it was instantiated with.
        """
        self.assertEqual(str(self.path.child(b'hello')),
                         "http://example.com/foo/bar/hello")
        self.assertEqual(str(self.path.child(b'hello').child(b'')),
                         "http://example.com/foo/bar/hello/")
        self.assertEqual(str(self.path.child(b'hello', keepQuery=True)),
                         "http://example.com/foo/bar/hello?yes=no&no=yes")


    def test_siblingString(self):
        """
        Calling C{str()} with a C{URLPath.sibling()} will return a URL which is
        the sibling of the URL it was instantiated with.
        """
        self.assertEqual(str(self.path.sibling(b'baz')),
                         'http://example.com/foo/baz')
        self.assertEqual(str(self.path.sibling(b'baz', keepQuery=True)),
                         "http://example.com/foo/baz?yes=no&no=yes")

        # The sibling of http://example.com/foo/bar/
        #     is http://example.comf/foo/bar/baz
        # because really we are constructing a sibling of
        # http://example.com/foo/bar/index.html
        self.assertEqual(str(self.path.child(b'').sibling(b'baz')),
                         'http://example.com/foo/bar/baz')


    def test_parentString(self):
        """
        Calling C{str()} with a C{URLPath.parent()} will return a URL which is
        the parent of the URL it was instantiated with.
        """
        # .parent() should be equivalent to '..'
        # 'foo' is the current directory, '/' is the parent directory
        self.assertEqual(str(self.path.parent()),
                         'http://example.com/')
        self.assertEqual(str(self.path.parent(keepQuery=True)),
                         'http://example.com/?yes=no&no=yes')
        self.assertEqual(str(self.path.child(b'').parent()),
                         'http://example.com/foo/')
        self.assertEqual(str(self.path.child(b'baz').parent()),
                         'http://example.com/foo/')
        self.assertEqual(
            str(self.path.parent().parent().parent().parent().parent()),
            'http://example.com/')


    def test_hereString(self):
        """
        Calling C{str()} with a C{URLPath.here()} will return a URL which is
        the URL that it was instantiated with, without any file, query, or
        fragment.
        """
        # .here() should be equivalent to '.'
        self.assertEqual(str(self.path.here()), 'http://example.com/foo/')
        self.assertEqual(str(self.path.here(keepQuery=True)),
                         'http://example.com/foo/?yes=no&no=yes')
        self.assertEqual(str(self.path.child(b'').here()),
                         'http://example.com/foo/bar/')


    def test_doubleSlash(self):
        """
        Calling L{urlpath.URLPath.click} on a L{urlpath.URLPath} with a
        trailing slash with a relative URL containing a leading slash will
        result in a URL with a single slash at the start of the path portion.
        """
        self.assertEqual(
            str(self.path.click(b"/hello/world")).encode("ascii"),
            b"http://example.com/hello/world"
        )


    def test_pathList(self):
        """
        L{urlpath.URLPath.pathList} returns a L{list} of L{bytes}.
        """
        self.assertEqual(
            self.path.child(b"%00%01%02").pathList(),
            [b"", b"foo", b"bar", b"%00%01%02"]
        )

        # Just testing that the 'copy' argument exists for compatibility; it
        # was originally provided for performance reasons, and its behavioral
        # contract is kind of nonsense (where is the state shared? who with?)
        # so it doesn't actually *do* anything any more.
        self.assertEqual(
            self.path.child(b"%00%01%02").pathList(copy=False),
            [b"", b"foo", b"bar", b"%00%01%02"]
        )
        self.assertEqual(
            self.path.child(b"%00%01%02").pathList(unquote=True),
            [b"", b"foo", b"bar", b"\x00\x01\x02"]
        )



class BytesURLPathTests(_BaseURLPathTests, unittest.TestCase):
    """
    Tests for interacting with a L{URLPath} created with C{fromBytes}.
    """
    def setUp(self):
        self.path = urlpath.URLPath.fromBytes(
            b"http://example.com/foo/bar?yes=no&no=yes#footer")


    def test_mustBeBytes(self):
        """
        L{URLPath.fromBytes} must take a L{bytes} argument.
        """
        with self.assertRaises(ValueError):
            urlpath.URLPath.fromBytes(None)

        with self.assertRaises(ValueError):
            urlpath.URLPath.fromBytes(u"someurl")


    def test_withoutArguments(self):
        """
        An instantiation with no arguments creates a usable L{URLPath} with
        default arguments.
        """
        url = urlpath.URLPath()
        self.assertEqual(str(url), "http://localhost/")


    def test_partialArguments(self):
        """
        Leaving some optional arguments unfilled makes a L{URLPath} with those
        optional arguments filled with defaults.
        """
        # Not a "full" URL given to fromBytes, no /
        # / is filled in
        url = urlpath.URLPath.fromBytes(b"http://google.com")
        self.assertEqual(url.scheme, b"http")
        self.assertEqual(url.netloc, b"google.com")
        self.assertEqual(url.path, b"/")
        self.assertEqual(url.fragment, b"")
        self.assertEqual(url.query, b"")
        self.assertEqual(str(url), "http://google.com/")


    def test_nonASCIIBytes(self):
        """
        L{URLPath.fromBytes} can interpret non-ASCII bytes as percent-encoded
        """
        url = urlpath.URLPath.fromBytes(b"http://example.com/\xff\x00")
        self.assertEqual(str(url), "http://example.com/%FF%00")



class StringURLPathTests(_BaseURLPathTests, unittest.TestCase):
    """
    Tests for interacting with a L{URLPath} created with C{fromString} and a
    L{str} argument.
    """
    def setUp(self):
        self.path = urlpath.URLPath.fromString(
            "http://example.com/foo/bar?yes=no&no=yes#footer")


    def test_mustBeStr(self):
        """
        C{URLPath.fromString} must take a L{str} or L{unicode} argument.
        """
        with self.assertRaises(ValueError):
            urlpath.URLPath.fromString(None)

        if _PY3:
            with self.assertRaises(ValueError):
                urlpath.URLPath.fromString(b"someurl")



class UnicodeURLPathTests(_BaseURLPathTests, unittest.TestCase):
    """
    Tests for interacting with a L{URLPath} created with C{fromString} and a
    L{unicode} argument.
    """
    def setUp(self):
        self.path = urlpath.URLPath.fromString(
            u"http://example.com/foo/bar?yes=no&no=yes#footer")


    def test_nonASCIICharacters(self):
        """
        L{URLPath.fromString} can load non-ASCII characters.
        """
        url = urlpath.URLPath.fromString(u"http://example.com/\xff\x00")
        self.assertEqual(str(url), "http://example.com/%C3%BF%00")

Filemanager

Name Type Size Permission Actions
__pycache__ Folder 0755
__init__.py File 42 B 0644
_deprecatetests.py.3only File 1.77 KB 0644
deprecatedattributes.py File 571 B 0644
modules_helpers.py File 1.57 KB 0644
pullpipe.py File 1.19 KB 0644
test_appdirs.py File 1.06 KB 0644
test_components.py File 25.37 KB 0644
test_constants.py File 37.22 KB 0644
test_deprecate.py File 38.02 KB 0644
test_dist3.py File 1.81 KB 0644
test_fakepwd.py File 13.78 KB 0644
test_htmlizer.py File 1.24 KB 0644
test_inotify.py File 3.55 KB 0644
test_release.py File 40.08 KB 0644
test_runtime.py File 7.74 KB 0644
test_sendmsg.py File 25.25 KB 0644
test_setup.py File 11.78 KB 0644
test_shellcomp.py File 21.32 KB 0644
test_syslog.py File 4.83 KB 0644
test_systemd.py File 6.25 KB 0644
test_textattributes.py File 712 B 0644
test_tzhelper.py File 3.89 KB 0644
test_url.py File 29.23 KB 0644
test_urlpath.py File 10.09 KB 0644
test_util.py File 35.55 KB 0644
test_versions.py File 5.27 KB 0644
test_zippath.py File 3.39 KB 0644
test_zipstream.py File 11.88 KB 0644