Vendor requests.

recipe_engine/third_party/requests/tests/test_utils.py

-# coding: utf-8
-from io import BytesIO
-
-import pytest
-from requests import compat
-from requests.structures import CaseInsensitiveDict
-from requests.utils import (
-    address_in_network, dotted_netmask,
-    get_auth_from_url, get_encoding_from_headers,
-    get_encodings_from_content, get_environ_proxies,
-    guess_filename, guess_json_utf, is_ipv4_address,
-    is_valid_cidr, iter_slices, parse_dict_header,
-    parse_header_links, prepend_scheme_if_needed,
-    requote_uri, select_proxy, super_len,
-    to_key_val_list, to_native_string,
-    unquote_header_value, unquote_unreserved,
-    urldefragauth)
-
-from .compat import StringIO, cStringIO
-
-
-class TestSuperLen:
-
-    @pytest.mark.parametrize(
-        'stream, value', (
-            (StringIO.StringIO, 'Test'),
-            (BytesIO, b'Test'),
-            pytest.mark.skipif('cStringIO is None')((cStringIO, 'Test')),
-        ))
-    def test_io_streams(self, stream, value):
-        """Ensures that we properly deal with different kinds of IO streams."""
-        assert super_len(stream()) == 0
-        assert super_len(stream(value)) == 4
-
-    def test_super_len_correctly_calculates_len_of_partially_read_file(self):
-        """Ensure that we handle partially consumed file like objects."""
-        s = StringIO.StringIO()
-        s.write('foobarbogus')
-        assert super_len(s) == 0
-
-    @pytest.mark.parametrize('error', [IOError, OSError])
-    def test_super_len_handles_files_raising_weird_errors_in_tell(self, error):
-        """
-        If tell() raises errors, assume the cursor is at position zero.
-        """
-        class BoomFile(object):
-            def __len__(self):
-                return 5
-
-            def tell(self):
-                raise error()
-
-        assert super_len(BoomFile()) == 0
-
-    def test_string(self):
-        assert super_len('Test') == 4
-
-    @pytest.mark.parametrize(
-        'mode, warnings_num', (
-            ('r', 1),
-            ('rb', 0),
-        ))
-    def test_file(self, tmpdir, mode, warnings_num, recwarn):
-        file_obj = tmpdir.join('test.txt')
-        file_obj.write('Test')
-        with file_obj.open(mode) as fd:
-            assert super_len(fd) == 4
-        assert len(recwarn) == warnings_num
-
-
-class TestToKeyValList:
-
-    @pytest.mark.parametrize(
-        'value, expected', (
-            ([('key', 'val')], [('key', 'val')]),
-            ((('key', 'val'), ), [('key', 'val')]),
-            ({'key': 'val'}, [('key', 'val')]),
-            (None, None)
-        ))
-    def test_valid(self, value, expected):
-        assert to_key_val_list(value) == expected
-
-    def test_invalid(self):
-        with pytest.raises(ValueError):
-            to_key_val_list('string')
-
-
-class TestUnquoteHeaderValue:
-
-    @pytest.mark.parametrize(
-        'value, expected', (
-            (None, None),
-            ('Test', 'Test'),
-            ('"Test"', 'Test'),
-            ('"Test\\\\"', 'Test\\'),
-            ('"\\\\Comp\\Res"', '\\Comp\\Res'),
-        ))
-    def test_valid(self, value, expected):
-        assert unquote_header_value(value) == expected
-
-    def test_is_filename(self):
-        assert unquote_header_value('"\\\\Comp\\Res"', True) == '\\\\Comp\\Res'
-
-
-class TestGetEnvironProxies:
-    """Ensures that IP addresses are correctly matches with ranges
-    in no_proxy variable."""
-
-    @pytest.fixture(autouse=True, params=['no_proxy', 'NO_PROXY'])
-    def no_proxy(self, request, monkeypatch):
-        monkeypatch.setenv(request.param, '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1')
-
-    @pytest.mark.parametrize(
-        'url', (
-            'http://192.168.0.1:5000/',
-            'http://192.168.0.1/',
-            'http://172.16.1.1/',
-            'http://172.16.1.1:5000/',
-            'http://localhost.localdomain:5000/v1.0/',
-        ))
-    def test_bypass(self, url):
-        assert get_environ_proxies(url) == {}
-
-    @pytest.mark.parametrize(
-        'url', (
-            'http://192.168.1.1:5000/',
-            'http://192.168.1.1/',
-            'http://www.requests.com/',
-        ))
-    def test_not_bypass(self, url):
-        assert get_environ_proxies(url) != {}
-
-
-class TestIsIPv4Address:
-
-    def test_valid(self):
-        assert is_ipv4_address('8.8.8.8')
-
-    @pytest.mark.parametrize('value', ('8.8.8.8.8', 'localhost.localdomain'))
-    def test_invalid(self, value):
-        assert not is_ipv4_address(value)
-
-
-class TestIsValidCIDR:
-
-    def test_valid(self):
-        assert is_valid_cidr('192.168.1.0/24')
-
-    @pytest.mark.parametrize(
-        'value', (
-            '8.8.8.8',
-            '192.168.1.0/a',
-            '192.168.1.0/128',
-            '192.168.1.0/-1',
-            '192.168.1.999/24',
-        ))
-    def test_invalid(self, value):
-        assert not is_valid_cidr(value)
-
-
-class TestAddressInNetwork:
-
-    def test_valid(self):
-        assert address_in_network('192.168.1.1', '192.168.1.0/24')
-
-    def test_invalid(self):
-        assert not address_in_network('172.16.0.1', '192.168.1.0/24')
-
-
-class TestGuessFilename:
-
-    @pytest.mark.parametrize(
-        'value', (1, type('Fake', (object,), {'name': 1})()),
-    )
-    def test_guess_filename_invalid(self, value):
-        assert guess_filename(value) is None
-
-    @pytest.mark.parametrize(
-        'value, expected_type', (
-            (b'value', compat.bytes),
-            (b'value'.decode('utf-8'), compat.str)
-        ))
-    def test_guess_filename_valid(self, value, expected_type):
-        obj = type('Fake', (object,), {'name': value})()
-        result = guess_filename(obj)
-        assert result == value
-        assert isinstance(result, expected_type)
-
-
-class TestContentEncodingDetection:
-
-    def test_none(self):
-        encodings = get_encodings_from_content('')
-        assert not len(encodings)
-
-    @pytest.mark.parametrize(
-        'content', (
-            # HTML5 meta charset attribute
-            '<meta charset="UTF-8">',
-            # HTML4 pragma directive
-            '<meta http-equiv="Content-type" content="text/html;charset=UTF-8">',
-            # XHTML 1.x served with text/html MIME type
-            '<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />',
-            # XHTML 1.x served as XML
-            '<?xml version="1.0" encoding="UTF-8"?>',
-        ))
-    def test_pragmas(self, content):
-        encodings = get_encodings_from_content(content)
-        assert len(encodings) == 1
-        assert encodings[0] == 'UTF-8'
-
-    def test_precedence(self):
-        content = '''
-        <?xml version="1.0" encoding="XML"?>
-        <meta charset="HTML5">
-        <meta http-equiv="Content-type" content="text/html;charset=HTML4" />
-        '''.strip()
-        assert get_encodings_from_content(content) == ['HTML5', 'HTML4', 'XML']
-
-
-class TestGuessJSONUTF:
-
-    @pytest.mark.parametrize(
-        'encoding', (
-            'utf-32', 'utf-8-sig', 'utf-16', 'utf-8', 'utf-16-be', 'utf-16-le',
-            'utf-32-be', 'utf-32-le'
-        ))
-    def test_encoded(self, encoding):
-        data = '{}'.encode(encoding)
-        assert guess_json_utf(data) == encoding
-
-    def test_bad_utf_like_encoding(self):
-        assert guess_json_utf(b'\x00\x00\x00\x00') is None
-
-
-USER = PASSWORD = "%!*'();:@&=+$,/?#[] "
-ENCODED_USER = compat.quote(USER, '')
-ENCODED_PASSWORD = compat.quote(PASSWORD, '')
-
-
-@pytest.mark.parametrize(
-    'url, auth', (
-        (
-            'http://' + ENCODED_USER + ':' + ENCODED_PASSWORD + '@' +
-            'request.com/url.html#test',
-            (USER, PASSWORD)
-        ),
-        (
-            'http://user:pass@complex.url.com/path?query=yes',
-            ('user', 'pass')
-        ),
-        (
-            'http://user:pass%20pass@complex.url.com/path?query=yes',
-            ('user', 'pass pass')
-        ),
-        (
-            'http://user:pass pass@complex.url.com/path?query=yes',
-            ('user', 'pass pass')
-        ),
-        (
-            'http://user%25user:pass@complex.url.com/path?query=yes',
-            ('user%user', 'pass')
-        ),
-        (
-            'http://user:pass%23pass@complex.url.com/path?query=yes',
-            ('user', 'pass#pass')
-        ),
-        (
-            'http://complex.url.com/path?query=yes',
-            ('', '')
-        ),
-    ))
-def test_get_auth_from_url(url, auth):
-    assert get_auth_from_url(url) == auth
-
-
-@pytest.mark.parametrize(
-    'uri, expected', (
-        (
-            # Ensure requoting doesn't break expectations
-            'http://example.com/fiz?buz=%25ppicture',
-            'http://example.com/fiz?buz=%25ppicture',
-        ),
-        (
-            # Ensure we handle unquoted percent signs in redirects
-            'http://example.com/fiz?buz=%ppicture',
-            'http://example.com/fiz?buz=%25ppicture',
-        ),
-    ))
-def test_requote_uri_with_unquoted_percents(uri, expected):
-    """See: https://github.com/kennethreitz/requests/issues/2356
-    """
-    assert requote_uri(uri) == expected
-
-
-@pytest.mark.parametrize(
-    'uri, expected', (
-        (
-            # Illegal bytes
-            'http://example.com/?a=%--',
-            'http://example.com/?a=%--',
-        ),
-        (
-            # Reserved characters
-            'http://example.com/?a=%300',
-            'http://example.com/?a=00',
-        )
-    ))
-def test_unquote_unreserved(uri, expected):
-    assert unquote_unreserved(uri) == expected
-
-
-@pytest.mark.parametrize(
-    'mask, expected', (
-        (8, '255.0.0.0'),
-        (24, '255.255.255.0'),
-        (25, '255.255.255.128'),
-    ))
-def test_dotted_netmask(mask, expected):
-    assert dotted_netmask(mask) == expected
-
-
-@pytest.mark.parametrize(
-    'url, expected', (
-        ('hTTp://u:p@Some.Host/path', 'http://some.host.proxy'),
-        ('hTTp://u:p@Other.Host/path', 'http://http.proxy'),
-        ('hTTps://Other.Host', None),
-        ('file:///etc/motd', None),
-    ))
-def test_select_proxies(url, expected):
-    """Make sure we can select per-host proxies correctly."""
-    proxies = {'http': 'http://http.proxy',
-               'http://some.host': 'http://some.host.proxy'}
-    assert select_proxy(url, proxies) == expected
-
-
-@pytest.mark.parametrize(
-    'value, expected', (
-        ('foo="is a fish", bar="as well"', {'foo': 'is a fish', 'bar': 'as well'}),
-        ('key_without_value', {'key_without_value': None})
-    ))
-def test_parse_dict_header(value, expected):
-    assert parse_dict_header(value) == expected
-
-
-@pytest.mark.parametrize(
-    'value, expected', (
-        (
-            CaseInsensitiveDict(),
-            None
-        ),
-        (
-            CaseInsensitiveDict({'content-type': 'application/json; charset=utf-8'}),
-            'utf-8'
-        ),
-        (
-            CaseInsensitiveDict({'content-type': 'text/plain'}),
-            'ISO-8859-1'
-        ),
-    ))
-def test_get_encoding_from_headers(value, expected):
-    assert get_encoding_from_headers(value) == expected
-
-
-@pytest.mark.parametrize(
-    'value, length', (
-        ('', 0),
-        ('T', 1),
-        ('Test', 4),
-    ))
-def test_iter_slices(value, length):
-    assert len(list(iter_slices(value, 1))) == length
-
-
-@pytest.mark.parametrize(
-    'value, expected', (
-        (
-            '<http:/.../front.jpeg>; rel=front; type="image/jpeg"',
-            [{'url': 'http:/.../front.jpeg', 'rel': 'front', 'type': 'image/jpeg'}]
-        ),
-        (
-            '<http:/.../front.jpeg>',
-            [{'url': 'http:/.../front.jpeg'}]
-        ),
-        (
-            '<http:/.../front.jpeg>;',
-            [{'url': 'http:/.../front.jpeg'}]
-        ),
-        (
-            '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;',
-            [
-                {'url': 'http:/.../front.jpeg', 'type': 'image/jpeg'},
-                {'url': 'http://.../back.jpeg'}
-            ]
-        ),
-    ))
-def test_parse_header_links(value, expected):
-    assert parse_header_links(value) == expected
-
-
-@pytest.mark.parametrize(
-    'value, expected', (
-        ('example.com/path', 'http://example.com/path'),
-        ('//example.com/path', 'http://example.com/path'),
-    ))
-def test_prepend_scheme_if_needed(value, expected):
-    assert prepend_scheme_if_needed(value, 'http') == expected
-
-
-@pytest.mark.parametrize(
-    'value, expected', (
-        ('T', 'T'),
-        (b'T', 'T'),
-        (u'T', 'T'),
-    ))
-def test_to_native_string(value, expected):
-    assert to_native_string(value) == expected
-
-
-@pytest.mark.parametrize(
-    'url, expected', (
-        ('http://u:p@example.com/path?a=1#test', 'http://example.com/path?a=1'),
-        ('http://example.com/path', 'http://example.com/path'),
-        ('//u:p@example.com/path', '//example.com/path'),
-        ('//example.com/path', '//example.com/path'),
-        ('example.com/path', '//example.com/path'),
-        ('scheme:u:p@example.com/path', 'scheme://example.com/path'),
-    ))
-def test_urldefragauth(url, expected):
-    assert urldefragauth(url) == expected