From 9817ec3e47bca8fba9a7cac56d785e9d644f7473 Mon Sep 17 00:00:00 2001 From: Lorry Tar Creator Date: Mon, 30 Jun 2014 23:17:28 +0000 Subject: Imported from /home/lorry/working-area/delta_python-packages_python-rfc3986/rfc3986-0.2.0.tar.gz. --- tests/conftest.py | 4 + tests/test_api.py | 16 ++ tests/test_normalizers.py | 72 ++++++++ tests/test_unicode_support.py | 26 +++ tests/test_uri.py | 408 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 526 insertions(+) create mode 100644 tests/conftest.py create mode 100644 tests/test_api.py create mode 100644 tests/test_normalizers.py create mode 100644 tests/test_unicode_support.py create mode 100644 tests/test_uri.py (limited to 'tests') diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..ba44dad --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 -*- +import sys + +sys.path.insert(0, '.') diff --git a/tests/test_api.py b/tests/test_api.py new file mode 100644 index 0000000..9e9189a --- /dev/null +++ b/tests/test_api.py @@ -0,0 +1,16 @@ +# -*- coding: utf-8 -*- +from rfc3986.api import ( + uri_reference, is_valid_uri, normalize_uri, URIReference + ) + + +def test_uri_reference(): + assert isinstance(uri_reference('http://example.com'), URIReference) + + +def test_is_valid_uri(): + assert is_valid_uri('http://example.com') is True + + +def test_normalize_uri(): + assert normalize_uri('HTTP://EXAMPLE.COM') == 'http://example.com' diff --git a/tests/test_normalizers.py b/tests/test_normalizers.py new file mode 100644 index 0000000..ddcb97b --- /dev/null +++ b/tests/test_normalizers.py @@ -0,0 +1,72 @@ +# -*- coding: utf-8 -*- +import pytest + +from rfc3986.uri import URIReference +from rfc3986.normalizers import ( + normalize_scheme, normalize_percent_characters, remove_dot_segments + ) + + +def test_normalize_scheme(): + assert 'http' == normalize_scheme('htTp') + assert 'http' == normalize_scheme('http') + assert 'http' == normalize_scheme('HTTP') + + +def test_normalize_percent_characters(): + expected = '%3Athis_should_be_lowercase%DF%AB%4C' + assert expected == normalize_percent_characters( + '%3athis_should_be_lowercase%DF%ab%4c') + assert expected == normalize_percent_characters( + '%3Athis_should_be_lowercase%DF%AB%4C') + assert expected == normalize_percent_characters( + '%3Athis_should_be_lowercase%DF%aB%4C') + + +paths = [ + # (Input, expected output) + ('/foo/bar/.', '/foo/bar/'), + ('/foo/bar/', '/foo/bar/'), + ('/foo/bar', '/foo/bar'), + ('./foo/bar', 'foo/bar'), + ('/./foo/bar', '/foo/bar'), + ('/foo%20bar/biz%2Abaz', '/foo%20bar/biz%2Abaz'), + ('../foo/bar', 'foo/bar'), + ('/../foo/bar', '/foo/bar'), + ('a/./b/../b/%63/%7Bfoo%7D', 'a/b/%63/%7Bfoo%7D'), + ('//a/./b/../b/%63/%7Bfoo%7D', '//a/b/%63/%7Bfoo%7D'), + ('mid/content=5/../6', 'mid/6'), + ('/a/b/c/./../../g', '/a/g'), + ] + + +@pytest.fixture(params=paths) +def path_fixture(request): + return request.param + + +@pytest.fixture(params=paths) +def uris(request): + to_norm, normalized = request.param + return (URIReference(None, None, to_norm, None, None), + URIReference(None, None, normalized, None, None)) + + +def test_remove_dot_segments(path_fixture): + to_normalize, expected = path_fixture + assert expected == remove_dot_segments(to_normalize) + + +def test_normalized_equality(uris): + assert uris[0] == uris[1] + + +def test_hostname_normalization(): + assert (URIReference(None, 'EXAMPLE.COM', None, None, None) == + URIReference(None, 'example.com', None, None, None)) + + +def test_authority_normalization(): + uri = URIReference( + None, 'user%2aName@EXAMPLE.COM', None, None, None).normalize() + assert uri.authority == 'user%2AName@example.com' diff --git a/tests/test_unicode_support.py b/tests/test_unicode_support.py new file mode 100644 index 0000000..0d6ea86 --- /dev/null +++ b/tests/test_unicode_support.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- + +from rfc3986 import uri_reference + + +def test_unicode_uri(): + url_bytestring = b'http://example.com?utf8=\xe2\x98\x83' + unicode_url = url_bytestring.decode('utf-8') + uri = uri_reference(unicode_url) + assert uri.is_valid() is True + assert uri == 'http://example.com?utf8=%E2%98%83' + + +def test_unicode_uri_passed_as_bytes(): + url_bytestring = b'http://example.com?utf8=\xe2\x98\x83' + uri = uri_reference(url_bytestring) + assert uri.is_valid() is True + assert uri == 'http://example.com?utf8=%E2%98%83' + + +def test_unicode_authority(): + url_bytestring = b'http://\xe2\x98\x83.com' + unicode_url = url_bytestring.decode('utf-8') + uri = uri_reference(unicode_url) + assert uri.is_valid() is False + assert uri == unicode_url diff --git a/tests/test_uri.py b/tests/test_uri.py new file mode 100644 index 0000000..8817a54 --- /dev/null +++ b/tests/test_uri.py @@ -0,0 +1,408 @@ +# -*- coding: utf-8 -*- +import pytest + +from rfc3986.exceptions import InvalidAuthority +from rfc3986.misc import URI_MATCHER +from rfc3986.uri import URIReference + + +valid_hosts = [ + '[21DA:00D3:0000:2F3B:02AA:00FF:FE28:9C5A]', '[::1]', + '[21DA:D3:0:2F3B:2AA:FF:FE28:9C5A]', '[FE80::2AA:FF:FE9A:4CA2]', + '[FF02::2]', '[FF02:3::5]', '[FF02:0:0:0:0:0:0:2]', + '[FF02:30:0:0:0:0:0:5]', '127.0.0.1', 'www.example.com', 'localhost' + ] + +invalid_hosts = [ + '[FF02::3::5]', # IPv6 can only have one :: + '[FADF:01]', # Not properly compacted (missing a :) + 'localhost:80:80:80' # Too many ports + ] + + +@pytest.fixture(params=valid_hosts) +def basic_uri(request): + return 'http://%s' % request.param + + +@pytest.fixture(params=valid_hosts) +def basic_uri_with_port(request): + return 'ftp://%s:21' % request.param + + +@pytest.fixture(params=valid_hosts) +def uri_with_port_and_userinfo(request): + return 'ssh://user:pass@%s:22' % request.param + + +@pytest.fixture(params=valid_hosts) +def basic_uri_with_path(request): + return 'http://%s/path/to/resource' % request.param + + +@pytest.fixture(params=valid_hosts) +def uri_with_path_and_query(request): + return 'http://%s/path/to/resource?key=value' % request.param + + +@pytest.fixture(params=valid_hosts) +def uri_with_everything(request): + return 'https://user:pass@%s:443/path/to/resource?key=value#fragment' % ( + request.param) + + +@pytest.fixture(params=valid_hosts) +def relative_uri(request): + return '//%s' % request.param + + +@pytest.fixture +def absolute_path_uri(): + return '/path/to/file' + + +@pytest.fixture(params=invalid_hosts) +def invalid_uri(request): + return 'https://%s' % request.param + + +@pytest.fixture +def scheme_and_path_uri(): + return 'mailto:user@example.com' + + +class TestURIReferenceParsesURIs: + """Tests for URIReference handling of URIs.""" + def test_handles_basic_uri(self, basic_uri): + """Test that URIReference can handle a simple URI.""" + uri = URIReference.from_string(basic_uri) + assert uri.scheme == 'http' + assert uri.authority == basic_uri[7:] # len('http://') + assert uri.host == uri.authority + assert uri.path is None + assert uri.query is None + assert uri.fragment is None + assert uri.port is None + assert uri.userinfo is None + + def test_handles_basic_uri_with_port(self, basic_uri_with_port): + """Test that URIReference can handle a simple URI with a port.""" + uri = URIReference.from_string(basic_uri_with_port) + assert uri.scheme == 'ftp' + assert uri.authority == basic_uri_with_port[6:] # len('ftp://') + assert uri.host != uri.authority + assert uri.port == '21' + assert uri.path is None + assert uri.query is None + assert uri.fragment is None + assert uri.userinfo is None + + def test_handles_uri_with_port_and_userinfo( + self, uri_with_port_and_userinfo): + """ + Test that URIReference can handle a URI with a port and userinfo. + """ + uri = URIReference.from_string(uri_with_port_and_userinfo) + assert uri.scheme == 'ssh' + # 6 == len('ftp://') + assert uri.authority == uri_with_port_and_userinfo[6:] + assert uri.host != uri.authority + assert uri.port == '22' + assert uri.path is None + assert uri.query is None + assert uri.fragment is None + assert uri.userinfo == 'user:pass' + + def test_handles_basic_uri_with_path(self, basic_uri_with_path): + """Test that URIReference can handle a URI with a path.""" + uri = URIReference.from_string(basic_uri_with_path) + assert uri.scheme == 'http' + assert basic_uri_with_path == (uri.scheme + '://' + uri.authority + + uri.path) + assert uri.host == uri.authority + assert uri.path == '/path/to/resource' + assert uri.query is None + assert uri.fragment is None + assert uri.userinfo is None + assert uri.port is None + + def test_handles_uri_with_path_and_query(self, uri_with_path_and_query): + """ + Test that URIReference can handle a URI with a path and query. + """ + uri = URIReference.from_string(uri_with_path_and_query) + assert uri.scheme == 'http' + assert uri.host == uri.authority + assert uri.path == '/path/to/resource' + assert uri.query == 'key=value' + assert uri.fragment is None + assert uri.userinfo is None + assert uri.port is None + + def test_handles_uri_with_everything(self, uri_with_everything): + """ + Test that URIReference can handle and with everything in it. + """ + uri = URIReference.from_string(uri_with_everything) + assert uri.scheme == 'https' + assert uri.path == '/path/to/resource' + assert uri.query == 'key=value' + assert uri.fragment == 'fragment' + assert uri.userinfo == 'user:pass' + assert uri.port == '443' + + def test_authority_info_raises_InvalidAuthority(self, invalid_uri): + """Test that an invalid IPv6 is caught by authority_info().""" + uri = URIReference.from_string(invalid_uri) + with pytest.raises(InvalidAuthority): + uri.authority_info() + + def test_attributes_catch_InvalidAuthority(self, invalid_uri): + """Test that an invalid IPv6 is caught by authority_info().""" + uri = URIReference.from_string(invalid_uri) + assert uri.host is None + assert uri.userinfo is None + assert uri.port is None + + def test_handles_relative_uri(self, relative_uri): + """Test that URIReference can handle a relative URI.""" + uri = URIReference.from_string(relative_uri) + assert uri.scheme is None + assert uri.authority == relative_uri[2:] + + def test_handles_absolute_path_uri(self, absolute_path_uri): + """Test that URIReference can handle a path-only URI.""" + uri = URIReference.from_string(absolute_path_uri) + assert uri.path == absolute_path_uri + assert uri.authority_info() == { + 'userinfo': None, + 'host': None, + 'port': None, + } + + def test_handles_scheme_and_path_uri(self, scheme_and_path_uri): + """Test that URIReference can handle a `scheme:path` URI.""" + uri = URIReference.from_string(scheme_and_path_uri) + assert uri.path == 'user@example.com' + assert uri.scheme == 'mailto' + assert uri.query is None + assert uri.host is None + assert uri.port is None + assert uri.userinfo is None + assert uri.authority is None + + +class TestURIValidation: + # Valid URI tests + def test_basic_uri_is_valid(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri.is_valid() is True + + def test_basic_uri_requiring_scheme(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri.is_valid(require_scheme=True) is True + + def test_basic_uri_requiring_authority(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri.is_valid(require_authority=True) is True + + def test_uri_with_everything_requiring_path(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri.is_valid(require_path=True) is True + + def test_uri_with_everything_requiring_query(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri.is_valid(require_query=True) is True + + def test_uri_with_everything_requiring_fragment(self, + uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri.is_valid(require_fragment=True) is True + + def test_basic_uri_with_port_is_valid(self, basic_uri_with_port): + uri = URIReference.from_string(basic_uri_with_port) + assert uri.is_valid() is True + + def test_uri_with_port_and_userinfo_is_valid(self, + uri_with_port_and_userinfo): + uri = URIReference.from_string(uri_with_port_and_userinfo) + assert uri.is_valid() is True + + def test_basic_uri_with_path_is_valid(self, basic_uri_with_path): + uri = URIReference.from_string(basic_uri_with_path) + assert uri.is_valid() is True + + def test_uri_with_path_and_query_is_valid(self, uri_with_path_and_query): + uri = URIReference.from_string(uri_with_path_and_query) + assert uri.is_valid() is True + + def test_uri_with_everything_is_valid(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri.is_valid() is True + + def test_relative_uri_is_valid(self, relative_uri): + uri = URIReference.from_string(relative_uri) + assert uri.is_valid() is True + + def test_absolute_path_uri_is_valid(self, absolute_path_uri): + uri = URIReference.from_string(absolute_path_uri) + assert uri.is_valid() is True + + def test_scheme_and_path_uri_is_valid(self, scheme_and_path_uri): + uri = URIReference.from_string(scheme_and_path_uri) + assert uri.is_valid() is True + + # Invalid URI tests + def test_invalid_uri_is_not_valid(self, invalid_uri): + uri = URIReference.from_string(invalid_uri) + assert uri.is_valid() is False + + def test_invalid_scheme(self): + uri = URIReference('123', None, None, None, None) + assert uri.is_valid() is False + + def test_invalid_path(self): + uri = URIReference(None, None, 'foo#bar', None, None) + assert uri.is_valid() is False + + def test_invalid_query_component(self): + uri = URIReference(None, None, None, 'foo#bar', None) + assert uri.is_valid() is False + + def test_invalid_fragment_component(self): + uri = URIReference(None, None, None, None, 'foo#bar') + assert uri.is_valid() is False + + +class TestURIReferenceUnsplits: + def test_basic_uri_unsplits(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri.unsplit() == basic_uri + + def test_basic_uri_with_port_unsplits(self, basic_uri_with_port): + uri = URIReference.from_string(basic_uri_with_port) + assert uri.unsplit() == basic_uri_with_port + + def test_uri_with_port_and_userinfo_unsplits(self, + uri_with_port_and_userinfo): + uri = URIReference.from_string(uri_with_port_and_userinfo) + assert uri.unsplit() == uri_with_port_and_userinfo + + def test_basic_uri_with_path_unsplits(self, basic_uri_with_path): + uri = URIReference.from_string(basic_uri_with_path) + assert uri.unsplit() == basic_uri_with_path + + def test_uri_with_path_and_query_unsplits(self, uri_with_path_and_query): + uri = URIReference.from_string(uri_with_path_and_query) + assert uri.unsplit() == uri_with_path_and_query + + def test_uri_with_everything_unsplits(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri.unsplit() == uri_with_everything + + def test_relative_uri_unsplits(self, relative_uri): + uri = URIReference.from_string(relative_uri) + assert uri.unsplit() == relative_uri + + def test_absolute_path_uri_unsplits(self, absolute_path_uri): + uri = URIReference.from_string(absolute_path_uri) + assert uri.unsplit() == absolute_path_uri + + def test_scheme_and_path_uri_unsplits(self, scheme_and_path_uri): + uri = URIReference.from_string(scheme_and_path_uri) + assert uri.unsplit() == scheme_and_path_uri + + +class TestURIReferenceComparesToStrings: + def test_basic_uri(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri == basic_uri + + def test_basic_uri_with_port(self, basic_uri_with_port): + uri = URIReference.from_string(basic_uri_with_port) + assert uri == basic_uri_with_port + + def test_uri_with_port_and_userinfo(self, uri_with_port_and_userinfo): + uri = URIReference.from_string(uri_with_port_and_userinfo) + assert uri == uri_with_port_and_userinfo + + def test_basic_uri_with_path(self, basic_uri_with_path): + uri = URIReference.from_string(basic_uri_with_path) + assert uri == basic_uri_with_path + + def test_uri_with_path_and_query(self, uri_with_path_and_query): + uri = URIReference.from_string(uri_with_path_and_query) + assert uri == uri_with_path_and_query + + def test_uri_with_everything(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri == uri_with_everything + + def test_relative_uri(self, relative_uri): + uri = URIReference.from_string(relative_uri) + assert uri == relative_uri + + def test_absolute_path_uri(self, absolute_path_uri): + uri = URIReference.from_string(absolute_path_uri) + assert uri == absolute_path_uri + + def test_scheme_and_path_uri(self, scheme_and_path_uri): + uri = URIReference.from_string(scheme_and_path_uri) + assert uri == scheme_and_path_uri + + +class TestURIReferenceComparesToTuples: + def to_tuple(self, uri): + return URI_MATCHER.match(uri).groups() + + def test_basic_uri(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri == self.to_tuple(basic_uri) + + def test_basic_uri_with_port(self, basic_uri_with_port): + uri = URIReference.from_string(basic_uri_with_port) + assert uri == self.to_tuple(basic_uri_with_port) + + def test_uri_with_port_and_userinfo(self, uri_with_port_and_userinfo): + uri = URIReference.from_string(uri_with_port_and_userinfo) + assert uri == self.to_tuple(uri_with_port_and_userinfo) + + def test_basic_uri_with_path(self, basic_uri_with_path): + uri = URIReference.from_string(basic_uri_with_path) + assert uri == self.to_tuple(basic_uri_with_path) + + def test_uri_with_path_and_query(self, uri_with_path_and_query): + uri = URIReference.from_string(uri_with_path_and_query) + assert uri == self.to_tuple(uri_with_path_and_query) + + def test_uri_with_everything(self, uri_with_everything): + uri = URIReference.from_string(uri_with_everything) + assert uri == self.to_tuple(uri_with_everything) + + def test_relative_uri(self, relative_uri): + uri = URIReference.from_string(relative_uri) + assert uri == self.to_tuple(relative_uri) + + def test_absolute_path_uri(self, absolute_path_uri): + uri = URIReference.from_string(absolute_path_uri) + assert uri == self.to_tuple(absolute_path_uri) + + def test_scheme_and_path_uri(self, scheme_and_path_uri): + uri = URIReference.from_string(scheme_and_path_uri) + assert uri == self.to_tuple(scheme_and_path_uri) + + +def test_uri_comparison_raises_TypeError(basic_uri): + uri = URIReference.from_string(basic_uri) + with pytest.raises(TypeError): + uri == 1 + + +class TestURIReferenceComparesToURIReferences: + def test_same_basic_uri(self, basic_uri): + uri = URIReference.from_string(basic_uri) + assert uri == uri + + def test_different_basic_uris(self, basic_uri, basic_uri_with_port): + uri = URIReference.from_string(basic_uri) + assert (uri == URIReference.from_string(basic_uri_with_port)) is False -- cgit v1.2.1