CasperSecurity
# -*- coding: utf-8 -*-
"""
Tests for hyperlink.hypothesis.
"""
try:
import hypothesis
del hypothesis
except ImportError:
pass
else:
from string import digits
from typing import Sequence, Text
try:
from unittest.mock import patch
except ImportError:
from mock import patch # type: ignore[misc]
from hypothesis import given, settings
from hypothesis.strategies import SearchStrategy, data
from idna import IDNAError, check_label, encode as idna_encode
from .common import HyperlinkTestCase
from .. import DecodedURL, EncodedURL
from ..hypothesis import (
DrawCallable,
composite,
decoded_urls,
encoded_urls,
hostname_labels,
hostnames,
idna_text,
paths,
port_numbers,
)
class TestHypothesisStrategies(HyperlinkTestCase):
"""
Tests for hyperlink.hypothesis.
"""
@given(idna_text())
def test_idna_text_valid(self, text):
# type: (Text) -> None
"""
idna_text() generates IDNA-encodable text.
"""
try:
idna_encode(text)
except IDNAError: # pragma: no cover
raise AssertionError("Invalid IDNA text: {!r}".format(text))
@given(data())
def test_idna_text_min_max(self, data):
# type: (SearchStrategy) -> None
"""
idna_text() raises AssertionError if min_size is < 1.
"""
self.assertRaises(AssertionError, data.draw, idna_text(min_size=0))
self.assertRaises(AssertionError, data.draw, idna_text(max_size=0))
@given(port_numbers())
def test_port_numbers_bounds(self, port):
# type: (int) -> None
"""
port_numbers() generates integers between 1 and 65535, inclusive.
"""
self.assertGreaterEqual(port, 1)
self.assertLessEqual(port, 65535)
@given(port_numbers(allow_zero=True))
def test_port_numbers_bounds_allow_zero(self, port):
# type: (int) -> None
"""
port_numbers(allow_zero=True) generates integers between 0 and
65535, inclusive.
"""
self.assertGreaterEqual(port, 0)
self.assertLessEqual(port, 65535)
@given(hostname_labels())
def test_hostname_labels_valid_idn(self, label):
# type: (Text) -> None
"""
hostname_labels() generates IDN host name labels.
"""
try:
check_label(label)
idna_encode(label)
except UnicodeError: # pragma: no cover
raise AssertionError("Invalid IDN label: {!r}".format(label))
@given(data())
@settings(max_examples=10)
def test_hostname_labels_long_idn_punycode(self, data):
# type: (SearchStrategy) -> None
"""
hostname_labels() handles case where idna_text() generates text
that encoded to punycode ends up as longer than allowed.
"""
@composite
def mock_idna_text(draw, min_size, max_size):
# type: (DrawCallable, int, int) -> Text
# We want a string that does not exceed max_size, but when
# encoded to punycode, does exceed max_size.
# So use a unicode character that is larger when encoded,
# "á" being a great example, and use it max_size times, which
# will be max_size * 3 in size when encoded.
return u"\N{LATIN SMALL LETTER A WITH ACUTE}" * max_size
with patch("hyperlink.hypothesis.idna_text", mock_idna_text):
label = data.draw(hostname_labels())
try:
check_label(label)
idna_encode(label)
except UnicodeError: # pragma: no cover
raise AssertionError(
"Invalid IDN label: {!r}".format(label)
)
@given(hostname_labels(allow_idn=False))
def test_hostname_labels_valid_ascii(self, label):
# type: (Text) -> None
"""
hostname_labels() generates a ASCII host name labels.
"""
try:
check_label(label)
label.encode("ascii")
except UnicodeError: # pragma: no cover
raise AssertionError("Invalid ASCII label: {!r}".format(label))
@given(hostnames())
def test_hostnames_idn(self, hostname):
# type: (Text) -> None
"""
hostnames() generates a IDN host names.
"""
try:
for label in hostname.split(u"."):
check_label(label)
idna_encode(hostname)
except UnicodeError: # pragma: no cover
raise AssertionError(
"Invalid IDN host name: {!r}".format(hostname)
)
@given(hostnames(allow_leading_digit=False))
def test_hostnames_idn_nolead(self, hostname):
# type: (Text) -> None
"""
hostnames(allow_leading_digit=False) generates a IDN host names
without leading digits.
"""
self.assertTrue(hostname == hostname.lstrip(digits))
@given(hostnames(allow_idn=False))
def test_hostnames_ascii(self, hostname):
# type: (Text) -> None
"""
hostnames() generates a ASCII host names.
"""
try:
for label in hostname.split(u"."):
check_label(label)
hostname.encode("ascii")
except UnicodeError: # pragma: no cover
raise AssertionError(
"Invalid ASCII host name: {!r}".format(hostname)
)
@given(hostnames(allow_leading_digit=False, allow_idn=False))
def test_hostnames_ascii_nolead(self, hostname):
# type: (Text) -> None
"""
hostnames(allow_leading_digit=False, allow_idn=False) generates
ASCII host names without leading digits.
"""
self.assertTrue(hostname == hostname.lstrip(digits))
@given(paths())
def test_paths(self, path):
# type: (Sequence[Text]) -> None
"""
paths() generates sequences of URL path components.
"""
text = u"/".join(path)
try:
text.encode("utf-8")
except UnicodeError: # pragma: no cover
raise AssertionError("Invalid URL path: {!r}".format(path))
for segment in path:
self.assertNotIn("#/?", segment)
@given(encoded_urls())
def test_encoded_urls(self, url):
# type: (EncodedURL) -> None
"""
encoded_urls() generates EncodedURLs.
"""
self.assertIsInstance(url, EncodedURL)
@given(decoded_urls())
def test_decoded_urls(self, url):
# type: (DecodedURL) -> None
"""
decoded_urls() generates DecodedURLs.
"""
self.assertIsInstance(url, DecodedURL)