Fleshed out tests for urllib requiring a network connection.

Lib/test/test_urllibnet.py

@@ -4,8 +4,10 @@ import unittest
 from test import test_support
 
 import socket
-import urllib2
+import urllib
 import sys
+import os
+import mimetools
 
 class URLTimeoutTest(unittest.TestCase):
 
@@ -18,12 +20,130 @@ class URLTimeoutTest(unittest.TestCase):
         socket.setdefaulttimeout(None)
 
     def testURLread(self):
-        f = urllib2.urlopen("http://www.python.org/")
+        f = urllib.urlopen("http://www.python.org/")
         x = f.read()
 
+class urlopenNetworkTests(unittest.TestCase):
+    """Tests urllib.urlopen using the network.
+    
+    These tests are not exhaustive.  Assuming that testing using files does a
+    good job overall of some of the basic interface features.  There are no
+    tests exercising the optional 'data' and 'proxies' arguments.  No tests
+    for transparent redirection have been written.
+    
+    setUp is not used for always constructing a connection to
+    http://www.python.org/ since there a few tests that don't use that address
+    and making a connection is expensive enough to warrant minimizing unneeded
+    connections.
+    
+    """
+
+    def test_basic(self):
+        # Simple test expected to pass.
+        open_url = urllib.urlopen("http://www.python.org/")
+        for attr in ("read", "readline", "readlines", "fileno", "close",
+                     "info", "geturl"):
+            self.assert_(hasattr(open_url, attr), "object returned from "
+                            "urlopen lacks the %s attribute" % attr)
+        try:
+            self.assert_(open_url.read(), "calling 'read' failed")
+        finally:
+            open_url.close()
+
+    def test_readlines(self):
+        # Test both readline and readlines.
+        open_url = urllib.urlopen("http://www.python.org/")
+        try:
+            self.assert_(isinstance(open_url.readline(), basestring),
+                         "readline did not return a string")
+            self.assert_(isinstance(open_url.readlines(), list),
+                         "readlines did not return a list")
+        finally:
+            open_url.close()
+
+    def test_info(self):
+        # Test 'info'.
+        open_url = urllib.urlopen("http://www.python.org/")
+        try:
+            info_obj = open_url.info()
+        finally:
+            open_url.close()
+            self.assert_(isinstance(info_obj, mimetools.Message),
+                         "object returned by 'info' is not an instance of "
+                         "mimetools.Message")
+            self.assertEqual(info_obj.getsubtype(), "html")
+
+    def test_geturl(self):
+        # Make sure same URL as opened is returned by geturl.
+        URL = "http://www.python.org/"
+        open_url = urllib.urlopen(URL)
+        try:
+            gotten_url = open_url.geturl()
+        finally:
+            open_url.close()
+        self.assertEqual(gotten_url, URL)
+
+    def test_fileno(self):
+        # Make sure fd returned by fileno is valid.
+        if hasattr(os, 'fdopen'):
+            open_url = urllib.urlopen("http://www.python.org/")
+            fd = open_url.fileno()
+            FILE = os.fdopen(fd)
+            try:
+                self.assert_(FILE.read(), "reading from file created using fd "
+                                          "returned by fileno failed")
+            finally:
+                FILE.close()
+
+    def test_bad_address(self):
+        # Make sure proper exception is raised when connecting to a bogus
+        # address.
+        self.assertRaises(IOError,
+                          urllib.urlopen, "http://www.sadflkjsasadf.com/")
+
+class urlretrieveNetworkTests(unittest.TestCase):
+    """Tests urllib.urlretrieve using the network."""
+
+    def test_basic(self):
+        # Test basic functionality.
+        file_location,info = urllib.urlretrieve("http://www.python.org/")
+        self.assert_(os.path.exists(file_location), "file location returned by"
+                        " urlretrieve is not a valid path")
+        FILE = file(file_location)
+        try:
+            self.assert_(FILE.read(), "reading from the file location returned "
+                                      "by urlretrieve failed")
+        finally:
+            FILE.close()
+            os.unlink(file_location)
+
+    def test_specified_path(self):
+        # Make sure that specifying the location of the file to write to works.
+        file_location,info = urllib.urlretrieve("http://www.python.org/",
+                                                test_support.TESTFN)
+        self.assertEqual(file_location, test_support.TESTFN)
+        self.assert_(os.path.exists(file_location))
+        FILE = file(file_location)
+        try:
+            self.assert_(FILE.read(), "reading from temporary file failed")
+        finally:
+            FILE.close()
+            os.unlink(file_location)
+
+    def test_header(self):
+        # Make sure header returned as 2nd value from urlretrieve is good.
+        file_location, header = urllib.urlretrieve("http://www.python.org/")
+        os.unlink(file_location)
+        self.assert_(isinstance(header, mimetools.Message),
+                     "header is not an instance of mimetools.Message")
+                     
+
+
 def test_main():
     test_support.requires('network')
-    test_support.run_unittest(URLTimeoutTest)
+    test_support.run_unittest(URLTimeoutTest,
+                              urlopenNetworkTests,
+                              urlretrieveNetworkTests)
 
 if __name__ == "__main__":
     test_main()