"""Escape char as RFC 2396 specifies"""

hex_repr = hex(ord(char))[2:].upper()

if len(hex_repr) == 1:

hex_repr = "0%s" % hex_repr

"""urlopen(url [, data]) -> open file-like object"""

global _urlopener

if proxies is not None:

opener = urllib_request.FancyURLopener(proxies=proxies)

elif not _urlopener:

with support.check_warnings(

('FancyURLopener style of invoking requests is deprecated.',

DeprecationWarning)):

opener = urllib_request.FancyURLopener()

_urlopener = opener

else:

opener = _urlopener

if data is None:

return opener.open(url)

else:

def fakehttp(self, fakedata):

class FakeSocket(io.BytesIO):

io_refs = 1

def sendall(self, data):

FakeHTTPConnection.buf = data

def makefile(self, *args, **kwds):

self.io_refs += 1

return self

def read(self, amt=None):

if self.closed:

return b""

return io.BytesIO.read(self, amt)

def readline(self, length=None):

if self.closed:

return b""

return io.BytesIO.readline(self, length)

def close(self):

self.io_refs -= 1

if self.io_refs == 0:

io.BytesIO.close(self)

class FakeHTTPConnection(http_client.HTTPConnection):

# buffer to store data for verification in urlopen tests.

buf = None

def connect(self):

self.sock = FakeSocket(fakedata)

self._connection_class = http_client.HTTPConnection

http_client.HTTPConnection = FakeHTTPConnection

def unfakehttp(self):

"""Test urlopen() opening a temporary file.

def setUp(self):

# Create a temp file to use for testing

self.text = bytes("test_urllib: %s\n" % self.__class__.__name__,

"ascii")

f = open(support.TESTFN, 'wb')

try:

f.write(self.text)

finally:

f.close()

self.pathname = support.TESTFN

self.returned_obj = urlopen("file:%s" % self.pathname)

def tearDown(self):

"""Shut down the open object"""

self.returned_obj.close()

os.remove(support.TESTFN)

def test_interface(self):

# Make sure object returned by urlopen() has the specified methods

for attr in ("read", "readline", "readlines", "fileno",

"close", "info", "geturl", "getcode", "__iter__"):

self.assertTrue(hasattr(self.returned_obj, attr),

"object returned by urlopen() lacks %s attribute" %

attr)

def test_read(self):

self.assertEqual(self.text, self.returned_obj.read())

def test_readline(self):

self.assertEqual(self.text, self.returned_obj.readline())

self.assertEqual(b'', self.returned_obj.readline(),

"calling readline() after exhausting the file did not"

" return an empty string")

def test_readlines(self):

lines_list = self.returned_obj.readlines()

self.assertEqual(len(lines_list), 1,

"readlines() returned the wrong number of lines")

self.assertEqual(lines_list[0], self.text,

"readlines() returned improper text")

def test_fileno(self):

file_num = self.returned_obj.fileno()

self.assertIsInstance(file_num, int, "fileno() did not return an int")

self.assertEqual(os.read(file_num, len(self.text)), self.text,

"Reading on the file descriptor returned by fileno() "

"did not return the expected text")

def test_close(self):

# Test close() by calling it here and then having it be called again

# by the tearDown() method for the test

self.returned_obj.close()

def test_info(self):

self.assertIsInstance(self.returned_obj.info(), email_message.Message)

def test_geturl(self):

self.assertEqual(self.returned_obj.geturl(), self.pathname)

def test_getcode(self):

self.assertIsNone(self.returned_obj.getcode())

def test_iter(self):

# Test iterator

# Don't need to count number of iterations since test would fail the

# instant it returned anything beyond the first line from the

# comparison.

# Use the iterator in the usual implicit way to test for ticket #4608.

for line in self.returned_obj:

self.assertEqual(line, self.text)

def test_relativelocalfile(self):

def setUp(self):

# Records changes to env vars

self.env = support.EnvironmentVarGuard()

# Delete all proxy related env vars

for k in list(os.environ):

if 'proxy' in k.lower():

self.env.unset(k)

def tearDown(self):

# Restore all proxy related env vars

self.env.__exit__()

del self.env

def test_getproxies_environment_keep_no_proxies(self):

self.env.set('NO_PROXY', 'localhost')

proxies = urllib_request.getproxies_environment()

# getproxies_environment use lowered case truncated (no '_proxy') keys

self.assertEqual('localhost', proxies['no'])

# List of no_proxies with space.

self.env.set('NO_PROXY', 'localhost, anotherdomain.com, newdomain.com')

"""Test urlopen() opening a fake http connection."""

def check_read(self, ver):

self.fakehttp(b"HTTP/" + ver + b" 200 OK\r\n\r\nHello!")

try:

fp = urlopen("http://python.org/")

self.assertEqual(fp.readline(), b"Hello!")

self.assertEqual(fp.readline(), b"")

self.assertEqual(fp.geturl(), 'http://python.org/')

self.assertEqual(fp.getcode(), 200)

finally:

self.unfakehttp()

def test_url_fragment(self):

# Issue #11703: geturl() omits fragments in the original URL.

url = 'http://docs.python.org/library/urllib.html#OK'

self.fakehttp(b"HTTP/1.1 200 OK\r\n\r\nHello!")

try:

fp = urllib_request.urlopen(url)

self.assertEqual(fp.geturl(), url)

finally:

self.unfakehttp()

def test_willclose(self):

self.fakehttp(b"HTTP/1.1 200 OK\r\n\r\nHello!")

try:

resp = urlopen("http://www.python.org")

self.assertTrue(resp.fp.will_close)

finally:

self.unfakehttp()

@expectedFailurePY26

def test_read_0_9(self):

# "0.9" response accepted (but not "simple responses" without

# a status line)

self.check_read(b"0.9")

@expectedFailurePY26

def test_read_1_0(self):

self.check_read(b"1.0")

@expectedFailurePY26

def test_read_1_1(self):

self.check_read(b"1.1")

def test_read_bogus(self):

# urlopen() should raise IOError for many error codes.

self.fakehttp(b'''HTTP/1.1 401 Authentication Required

''')

try:

self.assertRaises(IOError, urlopen, "http://python.org/")

finally:

self.unfakehttp()

def test_invalid_redirect(self):

# urlopen() should raise IOError for many error codes.

self.fakehttp(b'''HTTP/1.1 302 Found

''')

try:

self.assertRaises(urllib_error.HTTPError, urlopen,

"http://python.org/")

finally:

self.unfakehttp()

def test_empty_socket(self):

# urlopen() raises IOError if the underlying socket does not send any

# data. (#1680230)

self.fakehttp(b'')

try:

self.assertRaises(IOError, urlopen, "http://something")

finally:

self.unfakehttp()

def test_missing_localfile(self):

# Test for #10836

# 3.3 - URLError is not captured, explicit IOError is raised.

with self.assertRaises(IOError):

urlopen('file://localhost/a/file/which/doesnot/exists.py')

def test_file_notexists(self):

fd, tmp_file = tempfile.mkstemp()

tmp_fileurl = 'file://localhost/' + tmp_file.replace(os.path.sep, '/')

try:

self.assertTrue(os.path.exists(tmp_file))

with urlopen(tmp_fileurl) as fobj:

self.assertTrue(fobj)

finally:

os.close(fd)

os.unlink(tmp_file)

self.assertFalse(os.path.exists(tmp_file))

# 3.3 - IOError instead of URLError

with self.assertRaises(IOError):

urlopen(tmp_fileurl)

def test_ftp_nohost(self):

test_ftp_url = 'ftp:///path'

# 3.3 - IOError instead of URLError

with self.assertRaises(IOError):

urlopen(test_ftp_url)

def test_ftp_nonexisting(self):

# 3.3 - IOError instead of URLError

with self.assertRaises(IOError):

urlopen('ftp://localhost/a/file/which/doesnot/exists.py')

@expectedFailurePY26

def test_userpass_inurl(self):

self.fakehttp(b"HTTP/1.0 200 OK\r\n\r\nHello!")

try:

fp = urlopen("http://user:pass@python.org/")

self.assertEqual(fp.readline(), b"Hello!")

self.assertEqual(fp.readline(), b"")

self.assertEqual(fp.geturl(), 'http://user:pass@python.org/')

self.assertEqual(fp.getcode(), 200)

finally:

self.unfakehttp()

@expectedFailurePY26

def test_userpass_inurl_w_spaces(self):

self.fakehttp(b"HTTP/1.0 200 OK\r\n\r\nHello!")

try:

userpass = "a b:c d"

url = "http://{0}@python.org/".format(userpass)

fakehttp_wrapper = http_client.HTTPConnection

authorization = ("Authorization: Basic %s\r\n" %

b64encode(userpass.encode("ASCII")).decode("ASCII"))

fp = urlopen(url)

# The authorization header must be in place

self.assertIn(authorization, fakehttp_wrapper.buf.decode("UTF-8"))

self.assertEqual(fp.readline(), b"Hello!")

self.assertEqual(fp.readline(), b"")

# the spaces are quoted in URL so no match

self.assertNotEqual(fp.geturl(), url)

self.assertEqual(fp.getcode(), 200)

finally:

self.unfakehttp()

def test_URLopener_deprecation(self):

with support.check_warnings(('',DeprecationWarning)):

"""Test urllib.urlretrieve() on local files"""

def setUp(self):

# Create a list of temporary files. Each item in the list is a file

# name (absolute path or relative to the current working directory).

# All files in this list will be deleted in the tearDown method. Note,

# this only helps to makes sure temporary files get deleted, but it

# does nothing about trying to close files that may still be open. It

# is the responsibility of the developer to properly close files even

# when exceptional conditions occur.

self.tempFiles = []

# Create a temporary file.

self.registerFileForCleanUp(support.TESTFN)

self.text = b'testing urllib.urlretrieve'

try:

FILE = open(support.TESTFN, 'wb')

FILE.write(self.text)

FILE.close()

finally:

try: FILE.close()

except: pass

def tearDown(self):

# Delete the temporary files.

for each in self.tempFiles:

try: os.remove(each)

except: pass

def constructLocalFileUrl(self, filePath):

filePath = os.path.abspath(filePath)

try:

filePath.encode("utf-8")

except UnicodeEncodeError:

raise unittest.SkipTest("filePath is not encodable to utf8")

return "file://%s" % urllib_request.pathname2url(filePath)

def createNewTempFile(self, data=b""):

"""Creates a new temporary file containing the specified data,

newFd, newFilePath = tempfile.mkstemp()

try:

self.registerFileForCleanUp(newFilePath)

newFile = os.fdopen(newFd, "wb")

newFile.write(data)

newFile.close()

finally:

try: newFile.close()

except: pass

return newFilePath

def registerFileForCleanUp(self, fileName):

self.tempFiles.append(fileName)

def test_basic(self):

# Make sure that a local file just gets its own location returned and

# a headers value is returned.

result = urllib_request.urlretrieve("file:%s" % support.TESTFN)

self.assertEqual(result[0], support.TESTFN)

self.assertIsInstance(result[1], email_message.Message,

"did not get a email.message.Message instance "

"as second returned value")

def test_copy(self):

# Test that setting the filename argument works.

second_temp = "%s.2" % support.TESTFN

self.registerFileForCleanUp(second_temp)

result = urllib_request.urlretrieve(self.constructLocalFileUrl(

support.TESTFN), second_temp)

self.assertEqual(second_temp, result[0])

self.assertTrue(os.path.exists(second_temp), "copy of the file was not "

"made")

FILE = open(second_temp, 'rb')

try:

text = FILE.read()

FILE.close()

finally:

try: FILE.close()

except: pass

self.assertEqual(self.text, text)

def test_reporthook(self):

# Make sure that the reporthook works.

def hooktester(block_count, block_read_size, file_size, count_holder=[0]):

self.assertIsInstance(block_count, int)

self.assertIsInstance(block_read_size, int)

self.assertIsInstance(file_size, int)

self.assertEqual(block_count, count_holder[0])

count_holder[0] = count_holder[0] + 1

second_temp = "%s.2" % support.TESTFN

self.registerFileForCleanUp(second_temp)

urllib_request.urlretrieve(

self.constructLocalFileUrl(support.TESTFN),

second_temp, hooktester)

def test_reporthook_0_bytes(self):

# Test on zero length file. Should call reporthook only 1 time.

report = []

def hooktester(block_count, block_read_size, file_size, _report=report):

_report.append((block_count, block_read_size, file_size))

srcFileName = self.createNewTempFile()

urllib_request.urlretrieve(self.constructLocalFileUrl(srcFileName),

support.TESTFN, hooktester)

self.assertEqual(len(report), 1)

self.assertEqual(report[0][2], 0)

def test_reporthook_5_bytes(self):

# Test on 5 byte file. Should call reporthook only 2 times (once when

# the "network connection" is established and once when the block is

# read).

report = []

def hooktester(block_count, block_read_size, file_size, _report=report):

_report.append((block_count, block_read_size, file_size))

srcFileName = self.createNewTempFile(b"x" * 5)

urllib_request.urlretrieve(self.constructLocalFileUrl(srcFileName),

support.TESTFN, hooktester)

self.assertEqual(len(report), 2)

self.assertEqual(report[0][2], 5)

self.assertEqual(report[1][2], 5)

def test_reporthook_8193_bytes(self):

# Test on 8193 byte file. Should call reporthook only 3 times (once

# when the "network connection" is established, once for the next 8192

# bytes, and once for the last byte).

report = []

def hooktester(block_count, block_read_size, file_size, _report=report):

_report.append((block_count, block_read_size, file_size))

srcFileName = self.createNewTempFile(b"x" * 8193)

urllib_request.urlretrieve(self.constructLocalFileUrl(srcFileName),

support.TESTFN, hooktester)

self.assertEqual(len(report), 3)

self.assertEqual(report[0][2], 8193)

self.assertEqual(report[0][1], 8192)

self.assertEqual(report[1][1], 8192)

"""Test urllib.urlretrieve() using fake http connections"""

@skip26

def test_short_content_raises_ContentTooShortError(self):

self.fakehttp(b'''HTTP/1.1 200 OK

''')

def _reporthook(par1, par2, par3):

pass

with self.assertRaises(urllib_error.ContentTooShortError):

try:

urllib_request.urlretrieve('http://example.com/',

reporthook=_reporthook)

finally:

self.unfakehttp()

@skip26

def test_short_content_raises_ContentTooShortError_without_reporthook(self):

self.fakehttp(b'''HTTP/1.1 200 OK

''')

with self.assertRaises(urllib_error.ContentTooShortError):

try:

urllib_request.urlretrieve('http://example.com/')

finally:

"""Tests for urllib.quote() and urllib.quote_plus()

def test_never_quote(self):

# Make sure quote() does not quote letters, digits, and "_,.-"

do_not_quote = '' .join(["ABCDEFGHIJKLMNOPQRSTUVWXYZ",

"abcdefghijklmnopqrstuvwxyz",

"0123456789",

"_.-"])

result = urllib_parse.quote(do_not_quote)

self.assertEqual(do_not_quote, result,

"using quote(): %r != %r" % (do_not_quote, result))

result = urllib_parse.quote_plus(do_not_quote)

self.assertEqual(do_not_quote, result,

"using quote_plus(): %r != %r" % (do_not_quote, result))

def test_default_safe(self):

# Test '/' is default value for 'safe' parameter

self.assertEqual(urllib_parse.quote.__defaults__[0], '/')

def test_safe(self):

# Test setting 'safe' parameter does what it should do

quote_by_default = "<>"

result = urllib_parse.quote(quote_by_default, safe=quote_by_default)

self.assertEqual(quote_by_default, result,

"using quote(): %r != %r" % (quote_by_default, result))

result = urllib_parse.quote_plus(quote_by_default,

safe=quote_by_default)

self.assertEqual(quote_by_default, result,

"using quote_plus(): %r != %r" %

(quote_by_default, result))

# Safe expressed as bytes rather than str

result = urllib_parse.quote(quote_by_default, safe=b"<>")

self.assertEqual(quote_by_default, result,

"using quote(): %r != %r" % (quote_by_default, result))

# "Safe" non-ASCII characters should have no effect

# (Since URIs are not allowed to have non-ASCII characters)

result = urllib_parse.quote("a\xfcb", encoding="latin-1", safe="\xfc")

expect = urllib_parse.quote("a\xfcb", encoding="latin-1", safe="")

self.assertEqual(expect, result,

"using quote(): %r != %r" %

(expect, result))

# Same as above, but using a bytes rather than str

result = urllib_parse.quote("a\xfcb", encoding="latin-1", safe=b"\xfc")

expect = urllib_parse.quote("a\xfcb", encoding="latin-1", safe="")

self.assertEqual(expect, result,

"using quote(): %r != %r" %

(expect, result))

def test_default_quoting(self):

# Make sure all characters that should be quoted are by default sans

# space (separate test for that).

should_quote = [chr(num) for num in range(32)] # For 0x00 - 0x1F

should_quote.append('<>#%"{}|\^[]`')

should_quote.append(chr(127)) # For 0x7F

should_quote = ''.join(should_quote)

for char in should_quote:

result = urllib_parse.quote(char)

self.assertEqual(hexescape(char), result,

"using quote(): "

"%s should be escaped to %s, not %s" %

(char, hexescape(char), result))

result = urllib_parse.quote_plus(char)

self.assertEqual(hexescape(char), result,

"using quote_plus(): "

"%s should be escapes to %s, not %s" %

(char, hexescape(char), result))

del should_quote

partial_quote = "ab[]cd"

expected = "ab%5B%5Dcd"

result = urllib_parse.quote(partial_quote)

self.assertEqual(expected, result,

"using quote(): %r != %r" % (expected, result))

result = urllib_parse.quote_plus(partial_quote)

self.assertEqual(expected, result,

"using quote_plus(): %r != %r" % (expected, result))

def test_quoting_space(self):

# Make sure quote() and quote_plus() handle spaces as specified in

# their unique way

result = urllib_parse.quote(' ')

self.assertEqual(result, hexescape(' '),

"using quote(): %r != %r" % (result, hexescape(' ')))

result = urllib_parse.quote_plus(' ')

self.assertEqual(result, '+',

"using quote_plus(): %r != +" % result)

given = "a b cd e f"

expect = given.replace(' ', hexescape(' '))

result = urllib_parse.quote(given)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

expect = given.replace(' ', '+')

result = urllib_parse.quote_plus(given)

self.assertEqual(expect, result,

"using quote_plus(): %r != %r" % (expect, result))

def test_quoting_plus(self):

self.assertEqual(urllib_parse.quote_plus('alpha+beta gamma'),

'alpha%2Bbeta+gamma')

self.assertEqual(urllib_parse.quote_plus('alpha+beta gamma', '+'),

'alpha+beta+gamma')

# Test with bytes

self.assertEqual(urllib_parse.quote_plus(b'alpha+beta gamma'),

'alpha%2Bbeta+gamma')

# Test with safe bytes

self.assertEqual(urllib_parse.quote_plus('alpha+beta gamma', b'+'),

'alpha+beta+gamma')

def test_quote_bytes(self):

# Bytes should quote directly to percent-encoded values

given = b"\xa2\xd8ab\xff"

expect = "%A2%D8ab%FF"

result = urllib_parse.quote(given)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Encoding argument should raise type error on bytes input

self.assertRaises(TypeError, urllib_parse.quote, given,

encoding="latin-1")

# quote_from_bytes should work the same

result = urllib_parse.quote_from_bytes(given)

self.assertEqual(expect, result,

"using quote_from_bytes(): %r != %r"

% (expect, result))

def test_quote_with_unicode(self):

# Characters in Latin-1 range, encoded by default in UTF-8

given = "\xa2\xd8ab\xff"

expect = "%C2%A2%C3%98ab%C3%BF"

result = urllib_parse.quote(given)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Characters in Latin-1 range, encoded by with None (default)

result = urllib_parse.quote(given, encoding=None, errors=None)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Characters in Latin-1 range, encoded with Latin-1

given = "\xa2\xd8ab\xff"

expect = "%A2%D8ab%FF"

result = urllib_parse.quote(given, encoding="latin-1")

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Characters in BMP, encoded by default in UTF-8

given = "\u6f22\u5b57" # "Kanji"

expect = "%E6%BC%A2%E5%AD%97"

result = urllib_parse.quote(given)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Characters in BMP, encoded with Latin-1

given = "\u6f22\u5b57"

self.assertRaises(UnicodeEncodeError, urllib_parse.quote, given,

encoding="latin-1")

# Characters in BMP, encoded with Latin-1, with replace error handling

given = "\u6f22\u5b57"

expect = "%3F%3F" # "??"

result = urllib_parse.quote(given, encoding="latin-1",

errors="replace")

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

# Characters in BMP, Latin-1, with xmlcharref error handling

given = "\u6f22\u5b57"

expect = "%26%2328450%3B%26%2323383%3B" # "&#28450;&#23383;"

result = urllib_parse.quote(given, encoding="latin-1",

errors="xmlcharrefreplace")

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

def test_quote_plus_with_unicode(self):

# Encoding (latin-1) test for quote_plus

given = "\xa2\xd8 \xff"

expect = "%A2%D8+%FF"

result = urllib_parse.quote_plus(given, encoding="latin-1")

self.assertEqual(expect, result,

"using quote_plus(): %r != %r" % (expect, result))

# Errors test for quote_plus

given = "ab\u6f22\u5b57 cd"

expect = "ab%3F%3F+cd"

result = urllib_parse.quote_plus(given, encoding="latin-1",

errors="replace")

self.assertEqual(expect, result,

"""Tests for unquote() and unquote_plus()

def test_unquoting(self):

# Make sure unquoting of all ASCII values works

escape_list = []

for num in range(128):

given = hexescape(chr(num))

expect = chr(num)

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

result = urllib_parse.unquote_plus(given)

self.assertEqual(expect, result,

"using unquote_plus(): %r != %r" %

(expect, result))

escape_list.append(given)

escape_string = ''.join(escape_list)

del escape_list

result = urllib_parse.unquote(escape_string)

self.assertEqual(result.count('%'), 1,

"using unquote(): not all characters escaped: "

"%s" % result)

self.assertRaises((TypeError, AttributeError), urllib_parse.unquote, None)

self.assertRaises((TypeError, AttributeError), urllib_parse.unquote, ())

with support.check_warnings(('', BytesWarning), quiet=True):

self.assertRaises((TypeError, AttributeError), urllib_parse.unquote, bytes(b''))

def test_unquoting_badpercent(self):

# Test unquoting on bad percent-escapes

given = '%xab'

expect = given

result = urllib_parse.unquote(given)

self.assertEqual(expect, result, "using unquote(): %r != %r"

% (expect, result))

given = '%x'

expect = given

result = urllib_parse.unquote(given)

self.assertEqual(expect, result, "using unquote(): %r != %r"

% (expect, result))

given = '%'

expect = given

result = urllib_parse.unquote(given)

self.assertEqual(expect, result, "using unquote(): %r != %r"

% (expect, result))

# unquote_to_bytes

given = '%xab'

expect = bytes(given, 'ascii')

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r"

% (expect, result))

given = '%x'

expect = bytes(given, 'ascii')

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r"

% (expect, result))

given = '%'

expect = bytes(given, 'ascii')

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r"

% (expect, result))

self.assertRaises((TypeError, AttributeError), urllib_parse.unquote_to_bytes, None)

self.assertRaises((TypeError, AttributeError), urllib_parse.unquote_to_bytes, ())

def test_unquoting_mixed_case(self):

# Test unquoting on mixed-case hex digits in the percent-escapes

given = '%Ab%eA'

expect = b'\xab\xea'

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result,

"using unquote_to_bytes(): %r != %r"

% (expect, result))

def test_unquoting_parts(self):

# Make sure unquoting works when have non-quoted characters

# interspersed

given = 'ab%sd' % hexescape('c')

expect = "abcd"

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using quote(): %r != %r" % (expect, result))

result = urllib_parse.unquote_plus(given)

self.assertEqual(expect, result,

"using unquote_plus(): %r != %r" % (expect, result))

def test_unquoting_plus(self):

# Test difference between unquote() and unquote_plus()

given = "are+there+spaces..."

expect = given

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

expect = given.replace('+', ' ')

result = urllib_parse.unquote_plus(given)

self.assertEqual(expect, result,

"using unquote_plus(): %r != %r" % (expect, result))

def test_unquote_to_bytes(self):

given = 'br%C3%BCckner_sapporo_20050930.doc'

expect = b'br\xc3\xbcckner_sapporo_20050930.doc'

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result,

"using unquote_to_bytes(): %r != %r"

% (expect, result))

# Test on a string with unescaped non-ASCII characters

# (Technically an invalid URI; expect those characters to be UTF-8

# encoded).

result = urllib_parse.unquote_to_bytes("\u6f22%C3%BC")

expect = b'\xe6\xbc\xa2\xc3\xbc' # UTF-8 for "\u6f22\u00fc"

self.assertEqual(expect, result,

"using unquote_to_bytes(): %r != %r"

% (expect, result))

# Test with a bytes as input

given = b'%A2%D8ab%FF'

expect = b'\xa2\xd8ab\xff'

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result,

"using unquote_to_bytes(): %r != %r"

% (expect, result))

# Test with a bytes as input, with unescaped non-ASCII bytes

# (Technically an invalid URI; expect those bytes to be preserved)

given = b'%A2\xd8ab%FF'

expect = b'\xa2\xd8ab\xff'

result = urllib_parse.unquote_to_bytes(given)

self.assertEqual(expect, result,

"using unquote_to_bytes(): %r != %r"

% (expect, result))

def test_unquote_with_unicode(self):

# Characters in the Latin-1 range, encoded with UTF-8

given = 'br%C3%BCckner_sapporo_20050930.doc'

expect = 'br\u00fcckner_sapporo_20050930.doc'

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Characters in the Latin-1 range, encoded with None (default)

result = urllib_parse.unquote(given, encoding=None, errors=None)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Characters in the Latin-1 range, encoded with Latin-1

result = urllib_parse.unquote('br%FCckner_sapporo_20050930.doc',

encoding="latin-1")

expect = 'br\u00fcckner_sapporo_20050930.doc'

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Characters in BMP, encoded with UTF-8

given = "%E6%BC%A2%E5%AD%97"

expect = "\u6f22\u5b57" # "Kanji"

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Decode with UTF-8, invalid sequence

given = "%F3%B1"

expect = "\ufffd" # Replacement character

result = urllib_parse.unquote(given)

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Decode with UTF-8, invalid sequence, replace errors

result = urllib_parse.unquote(given, errors="replace")

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# Decode with UTF-8, invalid sequence, ignoring errors

given = "%F3%B1"

expect = ""

result = urllib_parse.unquote(given, errors="ignore")

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# A mix of non-ASCII and percent-encoded characters, UTF-8

result = urllib_parse.unquote("\u6f22%C3%BC")

expect = '\u6f22\u00fc'

self.assertEqual(expect, result,

"using unquote(): %r != %r" % (expect, result))

# A mix of non-ASCII and percent-encoded characters, Latin-1

# (Note, the string contains non-Latin-1-representable characters)

result = urllib_parse.unquote("\u6f22%FC", encoding="latin-1")

expect = '\u6f22\u00fc'

self.assertEqual(expect, result,

"""Tests for urlencode()"""

def help_inputtype(self, given, test_type):

"""Helper method for testing different input types.

expect_somewhere = ["1st=1", "2nd=2", "3rd=3"]

result = urllib_parse.urlencode(given)

for expected in expect_somewhere:

self.assertIn(expected, result,

"testing %s: %s not found in %s" %

(test_type, expected, result))

self.assertEqual(result.count('&'), 2,

"testing %s: expected 2 '&'s; got %s" %

(test_type, result.count('&')))

amp_location = result.index('&')

on_amp_left = result[amp_location - 1]

on_amp_right = result[amp_location + 1]

self.assertTrue(on_amp_left.isdigit() and on_amp_right.isdigit(),

"testing %s: '&' not located in proper place in %s" %

(test_type, result))

self.assertEqual(len(result), (5 * 3) + 2, #5 chars per thing and amps

"testing %s: "

"unexpected number of characters: %s != %s" %

(test_type, len(result), (5 * 3) + 2))

def test_using_mapping(self):

# Test passing in a mapping object as an argument.

self.help_inputtype({"1st":'1', "2nd":'2', "3rd":'3'},

"using dict as input type")

def test_using_sequence(self):

# Test passing in a sequence of two-item sequences as an argument.

self.help_inputtype([('1st', '1'), ('2nd', '2'), ('3rd', '3')],

"using sequence of two-item tuples as input")

def test_quoting(self):

# Make sure keys and values are quoted using quote_plus()

given = {"&":"="}

expect = "%s=%s" % (hexescape('&'), hexescape('='))

result = urllib_parse.urlencode(given)

self.assertEqual(expect, result)

given = {"key name":"A bunch of pluses"}

expect = "key+name=A+bunch+of+pluses"

result = urllib_parse.urlencode(given)

self.assertEqual(expect, result)

def test_doseq(self):

# Test that passing True for 'doseq' parameter works correctly

given = {'sequence':['1', '2', '3']}

expect = "sequence=%s" % urllib_parse.quote_plus(str(['1', '2', '3']))

result = urllib_parse.urlencode(given)

self.assertEqual(expect, result)

result = urllib_parse.urlencode(given, True)

for value in given["sequence"]:

expect = "sequence=%s" % value

self.assertIn(expect, result)

self.assertEqual(result.count('&'), 2,

"Expected 2 '&'s, got %s" % result.count('&'))

def test_empty_sequence(self):

self.assertEqual("", urllib_parse.urlencode({}))