6
from collections import deque
8
from unittest import mock
12
from requests import compat
13
from requests._internal_utils import unicode_is_ascii
14
from requests.cookies import RequestsCookieJar
15
from requests.structures import CaseInsensitiveDict
16
from requests.utils import (
17
_parse_content_type_header,
18
add_dict_to_cookiejar,
23
get_encoding_from_headers,
24
get_encodings_from_content,
34
prepend_scheme_if_needed,
38
should_bypass_proxies,
47
from .compat import StringIO, cStringIO
51
@pytest.mark.parametrize(
54
(StringIO.StringIO, "Test"),
57
cStringIO, "Test", marks=pytest.mark.skipif("cStringIO is None")
61
def test_io_streams(self, stream, value):
62
"""Ensures that we properly deal with different kinds of IO streams."""
63
assert super_len(stream()) == 0
64
assert super_len(stream(value)) == 4
61
def test_io_streams(self, stream, value):
62
"""Ensures that we properly deal with different kinds of IO streams."""
63
assert super_len(stream()) == 0
64
assert super_len(stream(value)) == 4
66
def test_super_len_correctly_calculates_len_of_partially_read_file(self):
67
"""Ensure that we handle partially consumed file like objects."""
68
s = StringIO.StringIO()
69
s.write("foobarbogus")
70
assert super_len(s) == 0
72
@pytest.mark.parametrize("error", [IOError, OSError])
73
def test_super_len_handles_files_raising_weird_errors_in_tell(self, error):
74
"""If tell() raises errors, assume the cursor is at position zero."""
83
assert super_len(BoomFile()) == 0
85
@pytest.mark.parametrize("error", [IOError, OSError])
86
def test_super_len_tell_ioerror(self, error):
87
"""Ensure that if tell gives an IOError super_len doesn't fail"""
93
def seek(self, offset, whence):
96
assert super_len(NoLenBoomFile()) == 0
98
def test_string(self):
99
assert super_len("Test") == 4
101
@pytest.mark.parametrize(
102
"mode, warnings_num",
108
def test_file(self, tmpdir, mode, warnings_num, recwarn):
109
file_obj = tmpdir.join("test.txt")
110
file_obj.write("Test")
111
with file_obj.open(mode) as fd:
112
assert super_len(fd) == 4
113
assert len(recwarn) == warnings_num
109
file_obj = tmpdir.join("test.txt")
110
file_obj.write("Test")
111
with file_obj.open(mode) as fd:
112
assert super_len(fd) == 4
113
assert len(recwarn) == warnings_num
115
def test_tarfile_member(self, tmpdir):
116
file_obj = tmpdir.join("test.txt")
117
file_obj.write("Test")
119
tar_obj = str(tmpdir.join("test.tar"))
120
with tarfile.open(tar_obj, "w") as tar:
121
tar.add(str(file_obj), arcname="test.txt")
123
with tarfile.open(tar_obj) as tar:
124
member = tar.extractfile("test.txt")
125
assert super_len(member) == 4
127
def test_super_len_with__len__(self):
129
len_foo = super_len(foo)
132
def test_super_len_with_no__len__(self):
137
assert super_len(LenFile()) == 5
139
def test_super_len_with_tell(self):
140
foo = StringIO.StringIO("12345")
141
assert super_len(foo) == 5
143
assert super_len(foo) == 3
145
def test_super_len_with_fileno(self):
146
with open(__file__, "rb") as f:
147
length = super_len(f)
149
assert length == len(file_data)
151
def test_super_len_with_no_matches(self):
152
"""Ensure that objects without any length methods default to 0"""
153
assert super_len(object()) == 0
149
assert length == len(file_data)
151
def test_super_len_with_no_matches(self):
152
"""Ensure that objects without any length methods default to 0"""
153
assert super_len(object()) == 0
156
class TestGetNetrcAuth:
157
def test_works(self, tmp_path, monkeypatch):
158
netrc_path = tmp_path / ".netrc"
159
monkeypatch.setenv("NETRC", str(netrc_path))
160
with open(netrc_path, "w") as f:
161
f.write("machine example.com login aaaa password bbbb\n")
162
auth = get_netrc_auth("http://example.com/thing")
163
assert auth == ("aaaa", "bbbb")
165
def test_not_vulnerable_to_bad_url_parsing(self, tmp_path, monkeypatch):
166
netrc_path = tmp_path / ".netrc"
167
monkeypatch.setenv("NETRC", str(netrc_path))
168
with open(netrc_path, "w") as f:
169
f.write("machine example.com login aaaa password bbbb\n")
170
auth = get_netrc_auth("http://example.com:@evil.com/'")
173
def test_empty_default_credentials_ignored(self, tmp_path, monkeypatch):
174
"""Empty default credentials should not be returned."""
175
netrc_path = tmp_path / ".netrc"
176
monkeypatch.setenv("NETRC", str(netrc_path))
177
with open(netrc_path, "w") as f:
178
f.write("machine example.com login user password pass\ndefault\n")
180
auth = get_netrc_auth("http://httpbin.org/")
184
class TestToKeyValList:
185
@pytest.mark.parametrize(
188
([("key", "val")], [("key", "val")]),
189
((("key", "val"),), [("key", "val")]),
190
({"key": "val"}, [("key", "val")]),
194
def test_valid(self, value, expected):
195
assert to_key_val_list(value) == expected
194
def test_valid(self, value, expected):
195
assert to_key_val_list(value) == expected
197
def test_invalid(self):
198
with pytest.raises(ValueError):
199
to_key_val_list("string")
202
class TestUnquoteHeaderValue:
203
@pytest.mark.parametrize(
209
('"Test\\\\"', "Test\\"),
210
('"\\\\Comp\\Res"', "\\Comp\\Res"),
213
def test_valid(self, value, expected):
214
assert unquote_header_value(value) == expected
216
def test_is_filename(self):
217
assert unquote_header_value('"\\\\Comp\\Res"', True) == "\\\\Comp\\Res"
220
class TestGetEnvironProxies:
221
"""Ensures that IP addresses are correctly matches with ranges
222
in no_proxy variable.
225
@pytest.fixture(autouse=True, params=["no_proxy", "NO_PROXY"])
226
def no_proxy(self, request, monkeypatch):
228
request.param, "192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1"
231
@pytest.mark.parametrize(
234
"http://192.168.0.1:5000/",
235
"http://192.168.0.1/",
236
"http://172.16.1.1/",
237
"http://172.16.1.1:5000/",
238
"http://localhost.localdomain:5000/v1.0/",
241
def test_bypass(self, url):
242
assert get_environ_proxies(url, no_proxy=None) == {}
238
"http://localhost.localdomain:5000/v1.0/",
241
def test_bypass(self, url):
242
assert get_environ_proxies(url, no_proxy=None) == {}
244
@pytest.mark.parametrize(
247
"http://192.168.1.1:5000/",
248
"http://192.168.1.1/",
249
"http://www.requests.com/",
252
def test_not_bypass(self, url):
253
assert get_environ_proxies(url, no_proxy=None) != {}
255
@pytest.mark.parametrize(
258
"http://192.168.1.1:5000/",
259
"http://192.168.1.1/",
260
"http://www.requests.com/",
263
def test_bypass_no_proxy_keyword(self, url):
264
no_proxy = "192.168.1.1,requests.com"
265
assert get_environ_proxies(url, no_proxy=no_proxy) == {}
267
@pytest.mark.parametrize(
270
"http://192.168.0.1:5000/",
271
"http://192.168.0.1/",
272
"http://172.16.1.1/",
273
"http://172.16.1.1:5000/",
274
"http://localhost.localdomain:5000/v1.0/",
277
def test_not_bypass_no_proxy_keyword(self, url, monkeypatch):
278
# This is testing that the 'no_proxy' argument overrides the
279
# environment variable 'no_proxy'
280
monkeypatch.setenv("http_proxy", "http://proxy.example.com:3128/")
281
no_proxy = "192.168.1.1,requests.com"
282
assert get_environ_proxies(url, no_proxy=no_proxy) != {}
278
# This is testing that the 'no_proxy' argument overrides the
279
# environment variable 'no_proxy'
280
monkeypatch.setenv("http_proxy", "http://proxy.example.com:3128/")
281
no_proxy = "192.168.1.1,requests.com"
282
assert get_environ_proxies(url, no_proxy=no_proxy) != {}
285
class TestIsIPv4Address:
286
def test_valid(self):
287
assert is_ipv4_address("8.8.8.8")
289
@pytest.mark.parametrize("value", ("8.8.8.8.8", "localhost.localdomain"))
290
def test_invalid(self, value):
291
assert not is_ipv4_address(value)
294
class TestIsValidCIDR:
295
def test_valid(self):
296
assert is_valid_cidr("192.168.1.0/24")
298
@pytest.mark.parametrize(
308
def test_invalid(self, value):
309
assert not is_valid_cidr(value)
312
class TestAddressInNetwork:
313
def test_valid(self):
314
assert address_in_network("192.168.1.1", "192.168.1.0/24")
316
def test_invalid(self):
317
assert not address_in_network("172.16.0.1", "192.168.1.0/24")
320
class TestGuessFilename:
321
@pytest.mark.parametrize(
323
(1, type("Fake", (object,), {"name": 1})()),
325
def test_guess_filename_invalid(self, value):
326
assert guess_filename(value) is None
328
@pytest.mark.parametrize(
329
"value, expected_type",
331
(b"value", compat.bytes),
332
(b"value".decode("utf-8"), compat.str),
335
def test_guess_filename_valid(self, value, expected_type):
336
obj = type("Fake", (object,), {"name": value})()
337
result = guess_filename(obj)
338
assert result == value
339
assert isinstance(result, expected_type)
335
def test_guess_filename_valid(self, value, expected_type):
336
obj = type("Fake", (object,), {"name": value})()
337
result = guess_filename(obj)
338
assert result == value
339
assert isinstance(result, expected_type)
342
class TestExtractZippedPaths:
343
@pytest.mark.parametrize(
349
"/etc/invalid/location",
352
def test_unzipped_paths_unchanged(self, path):
353
assert path == extract_zipped_paths(path)
355
def test_zipped_paths_extracted(self, tmpdir):
356
zipped_py = tmpdir.join("test.zip")
357
with zipfile.ZipFile(zipped_py.strpath, "w") as f:
360
_, name = os.path.splitdrive(__file__)
361
zipped_path = os.path.join(zipped_py.strpath, name.lstrip(r"\/"))
362
extracted_path = extract_zipped_paths(zipped_path)
365
assert extracted_path != zipped_path
366
assert os.path.exists(extracted_path)
367
assert filecmp.cmp(extracted_path, __file__)
369
os.remove(extracted_path)
371
def test_invalid_unc_path(self):
372
path = r"\\localhost\invalid\location"
373
assert extract_zipped_paths(path) == path
376
class TestContentEncodingDetection:
378
encodings = get_encodings_from_content("")
379
assert not len(encodings)
376
class TestContentEncodingDetection:
378
encodings = get_encodings_from_content("")
379
assert not len(encodings)
381
@pytest.mark.parametrize(
384
# HTML5 meta charset attribute
385
'<meta charset="UTF-8">',
386
# HTML4 pragma directive
387
'<meta http-equiv="Content-type" content="text/html;charset=UTF-8">',
388
# XHTML 1.x served with text/html MIME type
389
'<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />',
390
# XHTML 1.x served as XML
391
'<?xml version="1.0" encoding="UTF-8"?>',
394
def test_pragmas(self, content):
395
encodings = get_encodings_from_content(content)
396
assert len(encodings) == 1
397
assert encodings[0] == "UTF-8"
399
def test_precedence(self):
401
<?xml version="1.0" encoding="XML"?>
402
<meta charset="HTML5">
403
<meta http-equiv="Content-type" content="text/html;charset=HTML4" />
405
assert get_encodings_from_content(content) == ["HTML5", "HTML4", "XML"]
408
class TestGuessJSONUTF:
409
@pytest.mark.parametrize(
422
def test_encoded(self, encoding):
423
data = "{}".encode(encoding)
424
assert guess_json_utf(data) == encoding
422
def test_encoded(self, encoding):
423
data = "{}".encode(encoding)
424
assert guess_json_utf(data) == encoding
426
def test_bad_utf_like_encoding(self):
427
assert guess_json_utf(b"\x00\x00\x00\x00") is None
429
@pytest.mark.parametrize(
430
("encoding", "expected"),
432
("utf-16-be", "utf-16"),
433
("utf-16-le", "utf-16"),
434
("utf-32-be", "utf-32"),
435
("utf-32-le", "utf-32"),
438
def test_guess_by_bom(self, encoding, expected):
439
data = "\ufeff{}".encode(encoding)
440
assert guess_json_utf(data) == expected
443
USER = PASSWORD = "%!*'();:@&=+$,/?#[] "
444
ENCODED_USER = compat.quote(USER, "")
445
ENCODED_PASSWORD = compat.quote(PASSWORD, "")
448
@pytest.mark.parametrize(
452
f"http://{ENCODED_USER}:{ENCODED_PASSWORD}@request.com/url.html#test",
455
("http://user:pass@complex.url.com/path?query=yes", ("user", "pass")),
457
"http://user:pass%20pass@complex.url.com/path?query=yes",
458
("user", "pass pass"),
460
("http://user:pass pass@complex.url.com/path?query=yes", ("user", "pass pass")),
462
"http://user%25user:pass@complex.url.com/path?query=yes",
463
("user%user", "pass"),
466
"http://user:pass%23pass@complex.url.com/path?query=yes",
467
("user", "pass#pass"),
469
("http://complex.url.com/path?query=yes", ("", "")),
472
def test_get_auth_from_url(url, auth):
473
assert get_auth_from_url(url) == auth
469
("http://complex.url.com/path?query=yes", ("", "")),
472
def test_get_auth_from_url(url, auth):
473
assert get_auth_from_url(url) == auth
476
@pytest.mark.parametrize(
480
# Ensure requoting doesn't break expectations
481
"http://example.com/fiz?buz=%25ppicture",
482
"http://example.com/fiz?buz=%25ppicture",
485
# Ensure we handle unquoted percent signs in redirects
486
"http://example.com/fiz?buz=%ppicture",
487
"http://example.com/fiz?buz=%25ppicture",
491
def test_requote_uri_with_unquoted_percents(uri, expected):
492
"""See: https://github.com/psf/requests/issues/2356"""
493
assert requote_uri(uri) == expected
496
@pytest.mark.parametrize(
501
"http://example.com/?a=%--",
502
"http://example.com/?a=%--",
505
# Reserved characters
506
"http://example.com/?a=%300",
507
"http://example.com/?a=00",
511
def test_unquote_unreserved(uri, expected):
512
assert unquote_unreserved(uri) == expected
515
@pytest.mark.parametrize(
519
(24, "255.255.255.0"),
520
(25, "255.255.255.128"),
523
def test_dotted_netmask(mask, expected):
524
assert dotted_netmask(mask) == expected
520
(25, "255.255.255.128"),
523
def test_dotted_netmask(mask, expected):
524
assert dotted_netmask(mask) == expected
528
"http": "http://http.proxy",
529
"http://some.host": "http://some.host.proxy",
532
"all": "socks5://http.proxy",
533
"all://some.host": "socks5://some.host.proxy",
536
"http": "http://http.proxy",
537
"http://some.host": "http://some.host.proxy",
538
"all": "socks5://http.proxy",
542
@pytest.mark.parametrize(
543
"url, expected, proxies",
545
("hTTp://u:p@Some.Host/path", "http://some.host.proxy", http_proxies),
546
("hTTp://u:p@Other.Host/path", "http://http.proxy", http_proxies),
547
("hTTp:///path", "http://http.proxy", http_proxies),
548
("hTTps://Other.Host", None, http_proxies),
549
("file:///etc/motd", None, http_proxies),
550
("hTTp://u:p@Some.Host/path", "socks5://some.host.proxy", all_proxies),
551
("hTTp://u:p@Other.Host/path", "socks5://http.proxy", all_proxies),
552
("hTTp:///path", "socks5://http.proxy", all_proxies),
553
("hTTps://Other.Host", "socks5://http.proxy", all_proxies),
554
("http://u:p@other.host/path", "http://http.proxy", mixed_proxies),
555
("http://u:p@some.host/path", "http://some.host.proxy", mixed_proxies),
556
("https://u:p@other.host/path", "socks5://http.proxy", mixed_proxies),
557
("https://u:p@some.host/path", "socks5://http.proxy", mixed_proxies),
558
("https://", "socks5://http.proxy", mixed_proxies),
559
# XXX: unsure whether this is reasonable behavior
560
("file:///etc/motd", "socks5://http.proxy", all_proxies),
563
def test_select_proxies(url, expected, proxies):
564
"""Make sure we can select per-host proxies correctly."""
565
assert select_proxy(url, proxies) == expected
563
def test_select_proxies(url, expected, proxies):
564
"""Make sure we can select per-host proxies correctly."""
565
assert select_proxy(url, proxies) == expected
568
@pytest.mark.parametrize(
571
('foo="is a fish", bar="as well"', {"foo": "is a fish", "bar": "as well"}),
572
("key_without_value", {"key_without_value": None}),
575
def test_parse_dict_header(value, expected):
576
assert parse_dict_header(value) == expected
579
@pytest.mark.parametrize(
582
("application/xml", ("application/xml", {})),
584
"application/json ; charset=utf-8",
585
("application/json", {"charset": "utf-8"}),
588
"application/json ; Charset=utf-8",
589
("application/json", {"charset": "utf-8"}),
591
("text/plain", ("text/plain", {})),
593
"multipart/form-data; boundary = something ; boundary2='something_else' ; no_equals ",
595
"multipart/form-data",
597
"boundary": "something",
598
"boundary2": "something_else",
603
'multipart/form-data; boundary = something ; boundary2="something_else" ; no_equals ',
605
"multipart/form-data",
607
"boundary": "something",
608
"boundary2": "something_else",
613
"multipart/form-data; boundary = something ; 'boundary2=something_else' ; no_equals ",
615
"multipart/form-data",
617
"boundary": "something",
618
"boundary2": "something_else",
623
'multipart/form-data; boundary = something ; "boundary2=something_else" ; no_equals ',
625
"multipart/form-data",
627
"boundary": "something",
628
"boundary2": "something_else",
632
("application/json ; ; ", ("application/json", {})),
635
def test__parse_content_type_header(value, expected):
636
assert _parse_content_type_header(value) == expected
632
("application/json ; ; ", ("application/json", {})),
635
def test__parse_content_type_header(value, expected):
636
assert _parse_content_type_header(value) == expected
639
@pytest.mark.parametrize(
642
(CaseInsensitiveDict(), None),
644
CaseInsensitiveDict({"content-type": "application/json; charset=utf-8"}),
647
(CaseInsensitiveDict({"content-type": "text/plain"}), "ISO-8859-1"),
649
CaseInsensitiveDict({"content-type": "text/html; charset"}),
654
def test_get_encoding_from_headers(value, expected):
655
assert get_encoding_from_headers(value) == expected
658
@pytest.mark.parametrize(
669
def test_iter_slices(value, length):
670
if length is None or (length <= 0 and len(value) > 0):
671
# Reads all content at once
672
assert len(list(iter_slices(value, length))) == 1
674
assert len(list(iter_slices(value, 1))) == length
677
@pytest.mark.parametrize(
681
'<http:/.../front.jpeg>; rel=front; type="image/jpeg"',
682
[{"url": "http:/.../front.jpeg", "rel": "front", "type": "image/jpeg"}],
684
("<http:/.../front.jpeg>", [{"url": "http:/.../front.jpeg"}]),
685
("<http:/.../front.jpeg>;", [{"url": "http:/.../front.jpeg"}]),
687
'<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;',
689
{"url": "http:/.../front.jpeg", "type": "image/jpeg"},
690
{"url": "http://.../back.jpeg"},
696
def test_parse_header_links(value, expected):
697
assert parse_header_links(value) == expected
696
def test_parse_header_links(value, expected):
697
assert parse_header_links(value) == expected
700
@pytest.mark.parametrize(
703
("example.com/path", "http://example.com/path"),
704
("//example.com/path", "http://example.com/path"),
705
("example.com:80", "http://example.com:80"),
707
"http://user:pass@example.com/path?query",
708
"http://user:pass@example.com/path?query",
710
("http://user@example.com/path?query", "http://user@example.com/path?query"),
713
def test_prepend_scheme_if_needed(value, expected):
714
assert prepend_scheme_if_needed(value, "http") == expected
717
@pytest.mark.parametrize(
725
def test_to_native_string(value, expected):
726
assert to_native_string(value) == expected
729
@pytest.mark.parametrize(
732
("http://u:p@example.com/path?a=1#test", "http://example.com/path?a=1"),
733
("http://example.com/path", "http://example.com/path"),
734
("//u:p@example.com/path", "//example.com/path"),
735
("//example.com/path", "//example.com/path"),
736
("example.com/path", "//example.com/path"),
737
("scheme:u:p@example.com/path", "scheme://example.com/path"),
740
def test_urldefragauth(url, expected):
741
assert urldefragauth(url) == expected
737
("scheme:u:p@example.com/path", "scheme://example.com/path"),
740
def test_urldefragauth(url, expected):
741
assert urldefragauth(url) == expected
744
@pytest.mark.parametrize(
747
("http://192.168.0.1:5000/", True),
748
("http://192.168.0.1/", True),
749
("http://172.16.1.1/", True),
750
("http://172.16.1.1:5000/", True),
751
("http://localhost.localdomain:5000/v1.0/", True),
752
("http://google.com:6000/", True),
753
("http://172.16.1.12/", False),
754
("http://172.16.1.12:5000/", False),
755
("http://google.com:5000/v1.0/", False),
756
("file:///some/path/on/disk", True),
759
def test_should_bypass_proxies(url, expected, monkeypatch):
760
"""Tests for function should_bypass_proxies to check if proxy
761
can be bypassed or not
765
"192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1, google.com:6000",
769
"192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1, google.com:6000",
771
assert should_bypass_proxies(url, no_proxy=None) == expected
774
@pytest.mark.parametrize(
777
("http://172.16.1.1/", "172.16.1.1"),
778
("http://172.16.1.1:5000/", "172.16.1.1"),
779
("http://user:pass@172.16.1.1", "172.16.1.1"),
780
("http://user:pass@172.16.1.1:5000", "172.16.1.1"),
781
("http://hostname/", "hostname"),
782
("http://hostname:5000/", "hostname"),
783
("http://user:pass@hostname", "hostname"),
784
("http://user:pass@hostname:5000", "hostname"),
787
def test_should_bypass_proxies_pass_only_hostname(url, expected):
788
"""The proxy_bypass function should be called with a hostname or IP without
789
a port number or auth credentials.
791
with mock.patch("requests.utils.proxy_bypass") as proxy_bypass:
792
should_bypass_proxies(url, no_proxy=None)
793
proxy_bypass.assert_called_once_with(expected)
789
a port number or auth credentials.
791
with mock.patch("requests.utils.proxy_bypass") as proxy_bypass:
792
should_bypass_proxies(url, no_proxy=None)
793
proxy_bypass.assert_called_once_with(expected)
796
@pytest.mark.parametrize(
799
compat.cookielib.CookieJar(),
803
def test_add_dict_to_cookiejar(cookiejar):
804
"""Ensure add_dict_to_cookiejar works for
805
non-RequestsCookieJar CookieJars
807
cookiedict = {"test": "cookies", "good": "cookies"}
808
cj = add_dict_to_cookiejar(cookiejar, cookiedict)
809
cookies = {cookie.name: cookie.value for cookie in cj}
810
assert cookiedict == cookies
813
@pytest.mark.parametrize(
821
def test_unicode_is_ascii(value, expected):
822
assert unicode_is_ascii(value) is expected
825
@pytest.mark.parametrize(
828
("http://192.168.0.1:5000/", True),
829
("http://192.168.0.1/", True),
830
("http://172.16.1.1/", True),
831
("http://172.16.1.1:5000/", True),
832
("http://localhost.localdomain:5000/v1.0/", True),
833
("http://172.16.1.12/", False),
834
("http://172.16.1.12:5000/", False),
835
("http://google.com:5000/v1.0/", False),
838
def test_should_bypass_proxies_no_proxy(url, expected, monkeypatch):
839
"""Tests for function should_bypass_proxies to check if proxy
840
can be bypassed or not using the 'no_proxy' argument
842
no_proxy = "192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1"
843
# Test 'no_proxy' argument
844
assert should_bypass_proxies(url, no_proxy=no_proxy) == expected
840
can be bypassed or not using the 'no_proxy' argument
842
no_proxy = "192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1"
843
# Test 'no_proxy' argument
844
assert should_bypass_proxies(url, no_proxy=no_proxy) == expected
847
@pytest.mark.parametrize(
850
("http://localhost/", True),
851
("http://anotherdomain.com:8888/", True),
852
("http://newdomain.com:1234/", True),
853
("http://www.newdomain.com:1234/", True),
854
("http://foo.d.o.t/", True),
855
("http://d.o.t/", True),
856
("http://prelocalhost/", False),
857
("http://newdomain.com/", False),
858
("http://newdomain.com:1235/", False),
861
def test_should_bypass_proxies_no_proxy_domain_boundary(url, expected):
862
"""Ensure no_proxy matching respects domain boundaries and does not
863
greedily match domains that merely endswith the no_proxy entry.
864
See CPython bpo-39057.
866
no_proxy = "localhost, anotherdomain.com, newdomain.com:1234, .d.o.t"
867
assert should_bypass_proxies(url, no_proxy=no_proxy) == expected
870
@pytest.mark.skipif(os.name != "nt", reason="Test only on Windows")
871
@pytest.mark.parametrize(
872
"url, expected, override",
874
("http://192.168.0.1:5000/", True, None),
875
("http://192.168.0.1/", True, None),
876
("http://172.16.1.1/", True, None),
877
("http://172.16.1.1:5000/", True, None),
878
("http://localhost.localdomain:5000/v1.0/", True, None),
879
("http://172.16.1.22/", False, None),
880
("http://172.16.1.22:5000/", False, None),
881
("http://google.com:5000/v1.0/", False, None),
882
("http://mylocalhostname:5000/v1.0/", True, "<local>"),
883
("http://192.168.0.1/", False, ""),
886
def test_should_bypass_proxies_win_registry(url, expected, override, monkeypatch):
887
"""Tests for function should_bypass_proxies to check if proxy
888
can be bypassed or not with Windows registry settings
891
override = "192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1"
888
can be bypassed or not with Windows registry settings
891
override = "192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1"
898
ie_settings = RegHandle()
899
proxyEnableValues = deque([1, "1"])
901
def OpenKey(key, subkey):
904
def QueryValueEx(key, value_name):
905
if key is ie_settings:
906
if value_name == "ProxyEnable":
907
# this could be a string (REG_SZ) or a 32-bit number (REG_DWORD)
908
proxyEnableValues.rotate()
909
return [proxyEnableValues[0]]
910
elif value_name == "ProxyOverride":
913
monkeypatch.setenv("http_proxy", "")
914
monkeypatch.setenv("https_proxy", "")
915
monkeypatch.setenv("ftp_proxy", "")
916
monkeypatch.setenv("no_proxy", "")
917
monkeypatch.setenv("NO_PROXY", "")
918
monkeypatch.setattr(winreg, "OpenKey", OpenKey)
919
monkeypatch.setattr(winreg, "QueryValueEx", QueryValueEx)
920
assert should_bypass_proxies(url, None) == expected
923
@pytest.mark.skipif(os.name != "nt", reason="Test only on Windows")
924
def test_should_bypass_proxies_win_registry_bad_values(monkeypatch):
925
"""Tests for function should_bypass_proxies to check if proxy
926
can be bypassed or not with Windows invalid registry settings.
924
def test_should_bypass_proxies_win_registry_bad_values(monkeypatch):
925
"""Tests for function should_bypass_proxies to check if proxy
926
can be bypassed or not with Windows invalid registry settings.
934
ie_settings = RegHandle()
936
def OpenKey(key, subkey):
939
def QueryValueEx(key, value_name):
940
if key is ie_settings:
941
if value_name == "ProxyEnable":
942
# Invalid response; Should be an int or int-y value
944
elif value_name == "ProxyOverride":
945
return ["192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1"]
947
monkeypatch.setenv("http_proxy", "")
948
monkeypatch.setenv("https_proxy", "")
949
monkeypatch.setenv("no_proxy", "")
950
monkeypatch.setenv("NO_PROXY", "")
951
monkeypatch.setattr(winreg, "OpenKey", OpenKey)
952
monkeypatch.setattr(winreg, "QueryValueEx", QueryValueEx)
953
assert should_bypass_proxies("http://172.16.1.1/", None) is False
956
@pytest.mark.parametrize(
959
("no_proxy", "192.168.0.0/24,127.0.0.1,localhost.localdomain"),
961
("a_new_key", "192.168.0.0/24,127.0.0.1,localhost.localdomain"),
965
def test_set_environ(env_name, value):
966
"""Tests set_environ will set environ values and will restore the environ."""
967
environ_copy = copy.deepcopy(os.environ)
968
with set_environ(env_name, value):
969
assert os.environ.get(env_name) == value
965
def test_set_environ(env_name, value):
966
"""Tests set_environ will set environ values and will restore the environ."""
967
environ_copy = copy.deepcopy(os.environ)
968
with set_environ(env_name, value):
969
assert os.environ.get(env_name) == value
971
assert os.environ == environ_copy
974
def test_set_environ_raises_exception():
975
"""Tests set_environ will raise exceptions in context when the
976
value parameter is None."""
977
with pytest.raises(Exception) as exception:
978
with set_environ("test1", None):
979
raise Exception("Expected exception")
981
assert "Expected exception" in str(exception.value)
984
@pytest.mark.skipif(os.name != "nt", reason="Test only on Windows")
985
def test_should_bypass_proxies_win_registry_ProxyOverride_value(monkeypatch):
986
"""Tests for function should_bypass_proxies to check if proxy
987
can be bypassed or not with Windows ProxyOverride registry value ending with a semicolon.
995
ie_settings = RegHandle()
997
def OpenKey(key, subkey):
1000
def QueryValueEx(key, value_name):
1001
if key is ie_settings:
1002
if value_name == "ProxyEnable":
1004
elif value_name == "ProxyOverride":
1006
"192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1;<-loopback>;"
1004
elif value_name == "ProxyOverride":
1006
"192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1;<-loopback>;"
1009
monkeypatch.setenv("NO_PROXY", "")
1010
monkeypatch.setenv("no_proxy", "")
1011
monkeypatch.setattr(winreg, "OpenKey", OpenKey)
1012
monkeypatch.setattr(winreg, "QueryValueEx", QueryValueEx)
1013
assert should_bypass_proxies("http://example.com/", None) is False