CasperSecurity
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from typing import Dict, Union
from .. import DecodedURL, URL
from .._url import _percent_decode
from .common import HyperlinkTestCase
BASIC_URL = "http://example.com/#"
TOTAL_URL = (
"https://%75%73%65%72:%00%00%00%00@xn--bcher-kva.ch:8080/"
"a/nice%20nice/./path/?zot=23%25&zut#frég"
)
class TestURL(HyperlinkTestCase):
def test_durl_basic(self):
# type: () -> None
bdurl = DecodedURL.from_text(BASIC_URL)
assert bdurl.scheme == "http"
assert bdurl.host == "example.com"
assert bdurl.port == 80
assert bdurl.path == ("",)
assert bdurl.fragment == ""
durl = DecodedURL.from_text(TOTAL_URL)
assert durl.scheme == "https"
assert durl.host == "bücher.ch"
assert durl.port == 8080
assert durl.path == ("a", "nice nice", ".", "path", "")
assert durl.fragment == "frég"
assert durl.get("zot") == ["23%"]
assert durl.user == "user"
assert durl.userinfo == ("user", "\0\0\0\0")
def test_passthroughs(self):
# type: () -> None
# just basic tests for the methods that more or less pass straight
# through to the underlying URL
durl = DecodedURL.from_text(TOTAL_URL)
assert durl.sibling("te%t").path[-1] == "te%t"
assert durl.child("../test2%").path[-1] == "../test2%"
assert durl.child() == durl
assert durl.child() is durl
assert durl.click("/").path[-1] == ""
assert durl.user == "user"
assert "." in durl.path
assert "." not in durl.normalize().path
assert durl.to_uri().fragment == "fr%C3%A9g"
assert " " in durl.to_iri().path[1]
assert durl.to_text(with_password=True) == TOTAL_URL
assert durl.absolute
assert durl.rooted
assert durl == durl.encoded_url.get_decoded_url()
durl2 = DecodedURL.from_text(TOTAL_URL, lazy=True)
assert durl2 == durl2.encoded_url.get_decoded_url(lazy=True)
assert (
str(DecodedURL.from_text(BASIC_URL).child(" "))
== "http://example.com/%20"
)
assert not (durl == 1)
assert durl != 1
def test_repr(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
assert repr(durl) == "DecodedURL(url=" + repr(durl._url) + ")"
def test_query_manipulation(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
assert durl.get("zot") == ["23%"]
durl = durl.add(" ", "space")
assert durl.get(" ") == ["space"]
durl = durl.set(" ", "spa%ed")
assert durl.get(" ") == ["spa%ed"]
durl = DecodedURL(url=durl.to_uri())
assert durl.get(" ") == ["spa%ed"]
durl = durl.remove(" ")
assert durl.get(" ") == []
durl = DecodedURL.from_text("/?%61rg=b&arg=c")
assert durl.get("arg") == ["b", "c"]
assert durl.set("arg", "d").get("arg") == ["d"]
durl = DecodedURL.from_text(
"https://example.com/a/b/?fóó=1&bar=2&fóó=3"
)
assert durl.remove("fóó") == DecodedURL.from_text(
"https://example.com/a/b/?bar=2"
)
assert durl.remove("fóó", value="1") == DecodedURL.from_text(
"https://example.com/a/b/?bar=2&fóó=3"
)
assert durl.remove("fóó", limit=1) == DecodedURL.from_text(
"https://example.com/a/b/?bar=2&fóó=3"
)
assert durl.remove("fóó", value="1", limit=0) == DecodedURL.from_text(
"https://example.com/a/b/?fóó=1&bar=2&fóó=3"
)
def test_equality_and_hashability(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
durl2 = DecodedURL.from_text(TOTAL_URL)
burl = DecodedURL.from_text(BASIC_URL)
durl_uri = durl.to_uri()
assert durl == durl
assert durl == durl2
assert durl != burl
assert durl is not None
assert durl != durl._url
AnyURL = Union[URL, DecodedURL]
durl_map = {} # type: Dict[AnyURL, AnyURL]
durl_map[durl] = durl
durl_map[durl2] = durl2
assert len(durl_map) == 1
durl_map[burl] = burl
assert len(durl_map) == 2
durl_map[durl_uri] = durl_uri
assert len(durl_map) == 3
def test_replace_roundtrip(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
durl2 = durl.replace(
scheme=durl.scheme,
host=durl.host,
path=durl.path,
query=durl.query,
fragment=durl.fragment,
port=durl.port,
rooted=durl.rooted,
userinfo=durl.userinfo,
uses_netloc=durl.uses_netloc,
)
assert durl == durl2
def test_replace_userinfo(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
with self.assertRaises(ValueError):
durl.replace(
userinfo=( # type: ignore[arg-type]
"user",
"pw",
"thiswillcauseafailure",
)
)
return
def test_twisted_compat(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
assert durl == DecodedURL.fromText(TOTAL_URL)
assert "to_text" in dir(durl)
assert "asText" not in dir(durl)
assert durl.to_text() == durl.asText()
def test_percent_decode_mixed(self):
# type: () -> None
# See https://github.com/python-hyper/hyperlink/pull/59 for a
# nice discussion of the possibilities
assert _percent_decode("abcdé%C3%A9éfg") == "abcdéééfg"
# still allow percent encoding in the case of an error
assert _percent_decode("abcdé%C3éfg") == "abcdé%C3éfg"
# ...unless explicitly told otherwise
with self.assertRaises(UnicodeDecodeError):
_percent_decode("abcdé%C3éfg", raise_subencoding_exc=True)
# when not encodable as subencoding
assert _percent_decode("é%25é", subencoding="ascii") == "é%25é"
def test_click_decoded_url(self):
# type: () -> None
durl = DecodedURL.from_text(TOTAL_URL)
durl_dest = DecodedURL.from_text("/tëst")
clicked = durl.click(durl_dest)
assert clicked.host == durl.host
assert clicked.path == durl_dest.path
assert clicked.path == ("tëst",)
def test_decode_plus(self):
# type: () -> None
durl = DecodedURL.from_text("/x+y%2B?a=b+c%2B")
assert durl.path == ("x+y+",)
assert durl.get("a") == ["b c+"]
assert durl.query == (("a", "b c+"),)
def test_decode_nonplussed(self):
# type: () -> None
durl = DecodedURL.from_text(
"/x+y%2B?a=b+c%2B", query_plus_is_space=False
)
assert durl.path == ("x+y+",)
assert durl.get("a") == ["b+c+"]
assert durl.query == (("a", "b+c+"),)