home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_URLLIB.PY < prev    next >
Encoding:
Python Source  |  2003-08-05  |  17.3 KB  |  425 lines
  1. """Regresssion tests for urllib"""
  2.  
  3. import urllib
  4. import unittest
  5. from test import test_support
  6. import os
  7. import mimetools
  8.  
  9. def hexescape(char):
  10.     """Escape char as RFC 2396 specifies"""
  11.     hex_repr = hex(ord(char))[2:].upper()
  12.     if len(hex_repr) == 1:
  13.         hex_repr = "0%s" % hex_repr
  14.     return "%" + hex_repr
  15.  
  16. class urlopen_FileTests(unittest.TestCase):
  17.     """Test urlopen() opening a temporary file.
  18.  
  19.     Try to test as much functionality as possible so as to cut down on reliance
  20.     on connect to the Net for testing.
  21.  
  22.     """
  23.  
  24.     def setUp(self):
  25.         """Setup of a temp file to use for testing"""
  26.         self.text = "test_urllib: %s\n" % self.__class__.__name__
  27.         FILE = file(test_support.TESTFN, 'wb')
  28.         try:
  29.             FILE.write(self.text)
  30.         finally:
  31.             FILE.close()
  32.         self.pathname = test_support.TESTFN
  33.         self.returned_obj = urllib.urlopen("file:%s" % self.pathname)
  34.  
  35.     def tearDown(self):
  36.         """Shut down the open object"""
  37.         self.returned_obj.close()
  38.         os.remove(test_support.TESTFN)
  39.  
  40.     def test_interface(self):
  41.         # Make sure object returned by urlopen() has the specified methods
  42.         for attr in ("read", "readline", "readlines", "fileno",
  43.                      "close", "info", "geturl", "__iter__"):
  44.             self.assert_(hasattr(self.returned_obj, attr),
  45.                          "object returned by urlopen() lacks %s attribute" %
  46.                          attr)
  47.  
  48.     def test_read(self):
  49.         self.assertEqual(self.text, self.returned_obj.read())
  50.  
  51.     def test_readline(self):
  52.         self.assertEqual(self.text, self.returned_obj.readline())
  53.         self.assertEqual('', self.returned_obj.readline(),
  54.                          "calling readline() after exhausting the file did not"
  55.                          " return an empty string")
  56.  
  57.     def test_readlines(self):
  58.         lines_list = self.returned_obj.readlines()
  59.         self.assertEqual(len(lines_list), 1,
  60.                          "readlines() returned the wrong number of lines")
  61.         self.assertEqual(lines_list[0], self.text,
  62.                          "readlines() returned improper text")
  63.  
  64.     def test_fileno(self):
  65.         file_num = self.returned_obj.fileno()
  66.         self.assert_(isinstance(file_num, int),
  67.                      "fileno() did not return an int")
  68.         self.assertEqual(os.read(file_num, len(self.text)), self.text,
  69.                          "Reading on the file descriptor returned by fileno() "
  70.                          "did not return the expected text")
  71.  
  72.     def test_close(self):
  73.         # Test close() by calling it hear and then having it be called again
  74.         # by the tearDown() method for the test
  75.         self.returned_obj.close()
  76.  
  77.     def test_info(self):
  78.         self.assert_(isinstance(self.returned_obj.info(), mimetools.Message))
  79.  
  80.     def test_geturl(self):
  81.         self.assertEqual(self.returned_obj.geturl(), self.pathname)
  82.  
  83.     def test_iter(self):
  84.         # Test iterator
  85.         # Don't need to count number of iterations since test would fail the
  86.         # instant it returned anything beyond the first line from the
  87.         # comparison
  88.         for line in self.returned_obj.__iter__():
  89.             self.assertEqual(line, self.text)
  90.  
  91. class urlretrieve_FileTests(unittest.TestCase):
  92.     """Test urllib.urlretrieve() on local files"""
  93.  
  94.     def setUp(self):
  95.         # Create a temporary file.
  96.         self.text = 'testing urllib.urlretrieve'
  97.         FILE = file(test_support.TESTFN, 'wb')
  98.         FILE.write(self.text)
  99.         FILE.close()
  100.  
  101.     def tearDown(self):
  102.         # Delete the temporary file.
  103.         os.remove(test_support.TESTFN)
  104.  
  105.     def test_basic(self):
  106.         # Make sure that a local file just gets its own location returned and
  107.         # a headers value is returned.
  108.         result = urllib.urlretrieve("file:%s" % test_support.TESTFN)
  109.         self.assertEqual(os.path.normpath(result[0]), 
  110.                          os.path.normpath(test_support.TESTFN))
  111.         self.assert_(isinstance(result[1], mimetools.Message),
  112.                      "did not get a mimetools.Message instance as second "
  113.                      "returned value")
  114.  
  115.     def test_copy(self):
  116.         # Test that setting the filename argument works.
  117.         second_temp = "%s.2" % test_support.TESTFN
  118.         result = urllib.urlretrieve("file:%s" % test_support.TESTFN, second_temp)
  119.         self.assertEqual(second_temp, result[0])
  120.         self.assert_(os.path.exists(second_temp), "copy of the file was not "
  121.                                                   "made")
  122.         FILE = file(second_temp, 'rb')
  123.         try:
  124.             text = FILE.read()
  125.         finally:
  126.             FILE.close()
  127.         self.assertEqual(self.text, text)
  128.  
  129.     def test_reporthook(self):
  130.         # Make sure that the reporthook works.
  131.         def hooktester(count, block_size, total_size, count_holder=[0]):
  132.             self.assert_(isinstance(count, int))
  133.             self.assert_(isinstance(block_size, int))
  134.             self.assert_(isinstance(total_size, int))
  135.             self.assertEqual(count, count_holder[0])
  136.             count_holder[0] = count_holder[0] + 1
  137.         second_temp = "%s.2" % test_support.TESTFN
  138.         urllib.urlretrieve(test_support.TESTFN, second_temp, hooktester)
  139.         os.remove(second_temp)
  140.  
  141. class QuotingTests(unittest.TestCase):
  142.     """Tests for urllib.quote() and urllib.quote_plus()
  143.  
  144.     According to RFC 2396 ("Uniform Resource Identifiers), to escape a
  145.     character you write it as '%' + <2 character US-ASCII hex value>.  The Python
  146.     code of ``'%' + hex(ord(<character>))[2:]`` escapes a character properly.
  147.     Case does not matter on the hex letters.
  148.  
  149.     The various character sets specified are:
  150.  
  151.     Reserved characters : ";/?:@&=+$,"
  152.         Have special meaning in URIs and must be escaped if not being used for
  153.         their special meaning
  154.     Data characters : letters, digits, and "-_.!~*'()"
  155.         Unreserved and do not need to be escaped; can be, though, if desired
  156.     Control characters : 0x00 - 0x1F, 0x7F
  157.         Have no use in URIs so must be escaped
  158.     space : 0x20
  159.         Must be escaped
  160.     Delimiters : '<>#%"'
  161.         Must be escaped
  162.     Unwise : "{}|\^[]`"
  163.         Must be escaped
  164.  
  165.     """
  166.  
  167.     def test_never_quote(self):
  168.         # Make sure quote() does not quote letters, digits, and "_,.-"
  169.         do_not_quote = '' .join(["ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  170.                                  "abcdefghijklmnopqrstuvwxyz",
  171.                                  "0123456789",
  172.                                  "_.-"])
  173.         result = urllib.quote(do_not_quote)
  174.         self.assertEqual(do_not_quote, result,
  175.                          "using quote(): %s != %s" % (do_not_quote, result))
  176.         result = urllib.quote_plus(do_not_quote)
  177.         self.assertEqual(do_not_quote, result,
  178.                         "using quote_plus(): %s != %s" % (do_not_quote, result))
  179.  
  180.     def test_default_safe(self):
  181.         # Test '/' is default value for 'safe' parameter
  182.         self.assertEqual(urllib.quote.func_defaults[0], '/')
  183.  
  184.     def test_safe(self):
  185.         # Test setting 'safe' parameter does what it should do
  186.         quote_by_default = "<>"
  187.         result = urllib.quote(quote_by_default, safe=quote_by_default)
  188.         self.assertEqual(quote_by_default, result,
  189.                          "using quote(): %s != %s" % (quote_by_default, result))
  190.         result = urllib.quote_plus(quote_by_default, safe=quote_by_default)
  191.         self.assertEqual(quote_by_default, result,
  192.                          "using quote_plus(): %s != %s" %
  193.                          (quote_by_default, result))
  194.  
  195.     def test_default_quoting(self):
  196.         # Make sure all characters that should be quoted are by default sans
  197.         # space (separate test for that).
  198.         should_quote = [chr(num) for num in range(32)] # For 0x00 - 0x1F
  199.         should_quote.append('<>#%"{}|\^[]`')
  200.         should_quote.append(chr(127)) # For 0x7F
  201.         should_quote = ''.join(should_quote)
  202.         for char in should_quote:
  203.             result = urllib.quote(char)
  204.             self.assertEqual(hexescape(char), result,
  205.                              "using quote(): %s should be escaped to %s, not %s" %
  206.                              (char, hexescape(char), result))
  207.             result = urllib.quote_plus(char)
  208.             self.assertEqual(hexescape(char), result,
  209.                              "using quote_plus(): "
  210.                              "%s should be escapes to %s, not %s" %
  211.                              (char, hexescape(char), result))
  212.         del should_quote
  213.         partial_quote = "ab[]cd"
  214.         expected = "ab%5B%5Dcd"
  215.         result = urllib.quote(partial_quote)
  216.         self.assertEqual(expected, result,
  217.                          "using quote(): %s != %s" % (expected, result))
  218.         self.assertEqual(expected, result,
  219.                          "using quote_plus(): %s != %s" % (expected, result))
  220.  
  221.     def test_quoting_space(self):
  222.         # Make sure quote() and quote_plus() handle spaces as specified in
  223.         # their unique way
  224.         result = urllib.quote(' ')
  225.         self.assertEqual(result, hexescape(' '),
  226.                          "using quote(): %s != %s" % (result, hexescape(' ')))
  227.         result = urllib.quote_plus(' ')
  228.         self.assertEqual(result, '+',
  229.                          "using quote_plus(): %s != +" % result)
  230.         given = "a b cd e f"
  231.         expect = given.replace(' ', hexescape(' '))
  232.         result = urllib.quote(given)
  233.         self.assertEqual(expect, result,
  234.                          "using quote(): %s != %s" % (expect, result))
  235.         expect = given.replace(' ', '+')
  236.         result = urllib.quote_plus(given)
  237.         self.assertEqual(expect, result,
  238.                          "using quote_plus(): %s != %s" % (expect, result))
  239.  
  240. class UnquotingTests(unittest.TestCase):
  241.     """Tests for unquote() and unquote_plus()
  242.  
  243.     See the doc string for quoting_Tests for details on quoting and such.
  244.  
  245.     """
  246.  
  247.     def test_unquoting(self):
  248.         # Make sure unquoting of all ASCII values works
  249.         escape_list = []
  250.         for num in range(128):
  251.             given = hexescape(chr(num))
  252.             expect = chr(num)
  253.             result = urllib.unquote(given)
  254.             self.assertEqual(expect, result,
  255.                              "using unquote(): %s != %s" % (expect, result))
  256.             result = urllib.unquote_plus(given)
  257.             self.assertEqual(expect, result,
  258.                              "using unquote_plus(): %s != %s" %
  259.                              (expect, result))
  260.             escape_list.append(given)
  261.         escape_string = ''.join(escape_list)
  262.         del escape_list
  263.         result = urllib.unquote(escape_string)
  264.         self.assertEqual(result.count('%'), 1,
  265.                          "using quote(): not all characters escaped; %s" %
  266.                          result)
  267.         result = urllib.unquote(escape_string)
  268.         self.assertEqual(result.count('%'), 1,
  269.                          "using unquote(): not all characters escaped: "
  270.                          "%s" % result)
  271.  
  272.     def test_unquoting_parts(self):
  273.         # Make sure unquoting works when have non-quoted characters
  274.         # interspersed
  275.         given = 'ab%sd' % hexescape('c')
  276.         expect = "abcd"
  277.         result = urllib.unquote(given)
  278.         self.assertEqual(expect, result,
  279.                          "using quote(): %s != %s" % (expect, result))
  280.         result = urllib.unquote_plus(given)
  281.         self.assertEqual(expect, result,
  282.                          "using unquote_plus(): %s != %s" % (expect, result))
  283.  
  284.     def test_unquoting_plus(self):
  285.         # Test difference between unquote() and unquote_plus()
  286.         given = "are+there+spaces..."
  287.         expect = given
  288.         result = urllib.unquote(given)
  289.         self.assertEqual(expect, result,
  290.                          "using unquote(): %s != %s" % (expect, result))
  291.         expect = given.replace('+', ' ')
  292.         result = urllib.unquote_plus(given)
  293.         self.assertEqual(expect, result,
  294.                          "using unquote_plus(): %s != %s" % (expect, result))
  295.  
  296. class urlencode_Tests(unittest.TestCase):
  297.     """Tests for urlencode()"""
  298.  
  299.     def help_inputtype(self, given, test_type):
  300.         """Helper method for testing different input types.
  301.  
  302.         'given' must lead to only the pairs:
  303.             * 1st, 1
  304.             * 2nd, 2
  305.             * 3rd, 3
  306.  
  307.         Test cannot assume anything about order.  Docs make no guarantee and
  308.         have possible dictionary input.
  309.  
  310.         """
  311.         expect_somewhere = ["1st=1", "2nd=2", "3rd=3"]
  312.         result = urllib.urlencode(given)
  313.         for expected in expect_somewhere:
  314.             self.assert_(expected in result,
  315.                          "testing %s: %s not found in %s" %
  316.                          (test_type, expected, result))
  317.         self.assertEqual(result.count('&'), 2,
  318.                          "testing %s: expected 2 '&'s; got %s" %
  319.                          (test_type, result.count('&')))
  320.         amp_location = result.index('&')
  321.         on_amp_left = result[amp_location - 1]
  322.         on_amp_right = result[amp_location + 1]
  323.         self.assert_(on_amp_left.isdigit() and on_amp_right.isdigit(),
  324.                      "testing %s: '&' not located in proper place in %s" %
  325.                      (test_type, result))
  326.         self.assertEqual(len(result), (5 * 3) + 2, #5 chars per thing and amps
  327.                          "testing %s: "
  328.                          "unexpected number of characters: %s != %s" %
  329.                          (test_type, len(result), (5 * 3) + 2))
  330.  
  331.     def test_using_mapping(self):
  332.         # Test passing in a mapping object as an argument.
  333.         self.help_inputtype({"1st":'1', "2nd":'2', "3rd":'3'},
  334.                             "using dict as input type")
  335.  
  336.     def test_using_sequence(self):
  337.         # Test passing in a sequence of two-item sequences as an argument.
  338.         self.help_inputtype([('1st', '1'), ('2nd', '2'), ('3rd', '3')],
  339.                             "using sequence of two-item tuples as input")
  340.  
  341.     def test_quoting(self):
  342.         # Make sure keys and values are quoted using quote_plus()
  343.         given = {"&":"="}
  344.         expect = "%s=%s" % (hexescape('&'), hexescape('='))
  345.         result = urllib.urlencode(given)
  346.         self.assertEqual(expect, result)
  347.         given = {"key name":"A bunch of pluses"}
  348.         expect = "key+name=A+bunch+of+pluses"
  349.         result = urllib.urlencode(given)
  350.         self.assertEqual(expect, result)
  351.  
  352.     def test_doseq(self):
  353.         # Test that passing True for 'doseq' parameter works correctly
  354.         given = {'sequence':['1', '2', '3']}
  355.         expect = "sequence=%s" % urllib.quote_plus(str(['1', '2', '3']))
  356.         result = urllib.urlencode(given)
  357.         self.assertEqual(expect, result)
  358.         result = urllib.urlencode(given, True)
  359.         for value in given["sequence"]:
  360.             expect = "sequence=%s" % value
  361.             self.assert_(expect in result,
  362.                          "%s not found in %s" % (expect, result))
  363.         self.assertEqual(result.count('&'), 2,
  364.                          "Expected 2 '&'s, got %s" % result.count('&'))
  365.  
  366. class Pathname_Tests(unittest.TestCase):
  367.     """Test pathname2url() and url2pathname()"""
  368.  
  369.     def test_basic(self):
  370.         # Make sure simple tests pass
  371.         expected_path = os.path.join("parts", "of", "a", "path")
  372.         expected_url = "parts/of/a/path"
  373.         result = urllib.pathname2url(expected_path)
  374.         self.assertEqual(expected_url, result,
  375.                          "pathname2url() failed; %s != %s" %
  376.                          (result, expected_url))
  377.         result = urllib.url2pathname(expected_url)
  378.         self.assertEqual(expected_path, result,
  379.                          "url2pathame() failed; %s != %s" %
  380.                          (result, expected_path))
  381.  
  382.     def test_quoting(self):
  383.         # Test automatic quoting and unquoting works for pathnam2url() and
  384.         # url2pathname() respectively
  385.         given = os.path.join("needs", "quot=ing", "here")
  386.         expect = "needs/%s/here" % urllib.quote("quot=ing")
  387.         result = urllib.pathname2url(given)
  388.         self.assertEqual(expect, result,
  389.                          "pathname2url() failed; %s != %s" %
  390.                          (expect, result))
  391.         expect = given
  392.         result = urllib.url2pathname(result)
  393.         self.assertEqual(expect, result,
  394.                          "url2pathname() failed; %s != %s" %
  395.                          (expect, result))
  396.         given = os.path.join("make sure", "using_quote")
  397.         expect = "%s/using_quote" % urllib.quote("make sure")
  398.         result = urllib.pathname2url(given)
  399.         self.assertEqual(expect, result,
  400.                          "pathname2url() failed; %s != %s" %
  401.                          (expect, result))
  402.         given = "make+sure/using_unquote"
  403.         expect = os.path.join("make+sure", "using_unquote")
  404.         result = urllib.url2pathname(given)
  405.         self.assertEqual(expect, result,
  406.                          "url2pathname() failed; %s != %s" %
  407.                          (expect, result))
  408.  
  409.  
  410.  
  411. def test_main():
  412.     test_support.run_unittest(
  413.         urlopen_FileTests,
  414.         urlretrieve_FileTests,
  415.         QuotingTests,
  416.         UnquotingTests,
  417.         urlencode_Tests,
  418.         Pathname_Tests
  419.     )
  420.  
  421.  
  422.  
  423. if __name__ == '__main__':
  424.     test_main()
  425.