Merge lp:~pwlars/qa-iso-static-validation-test/pep8 into lp:qa-iso-static-validation-test

[Paul Larson]

No other changes or cleanups in this branch, just enough to make it pass
pep8 compliance.

[Para Siva (psivaa)]

review: Approve

=== modified file 'iso_static_validation.py'
--- iso_static_validation.py	2012-08-30 08:57:30 +0000
+++ iso_static_validation.py	2012-09-18 13:39:20 +0000
@@ -28,20 +28,19 @@
 import subprocess
 import hashlib
 import unittest
-import time
-import datetime
 import re
 import tempfile
 import shutil
 
 # Defaults
-#DEFAULT_ISOROOT = os.path.expanduser('/var/lib/ubuntu-server-iso-testing/isos/ubuntu/')
+#DEFAULT_ISOROOT = os.path.expanduser(
+#    '/var/lib/ubuntu-server-iso-testing/isos/ubuntu/')
 DEFAULT_URL = 'http://cdimage.ubuntu.com/'
 
 #constants
-ONE_MB_BLOCK=2**20
-PRECISE_SIZE_LIMIT_MB=737148928
-QUANTAL_SIZE_LIMIT_MB=838860800
+ONE_MB_BLOCK = 2 ** 20
+PRECISE_SIZE_LIMIT_MB = 737148928
+QUANTAL_SIZE_LIMIT_MB = 838860800
 
 #Read the iso name and initialise global variables
 parser = argparse.ArgumentParser()
@@ -49,10 +48,11 @@
 parser.add_argument('--name')
 args = parser.parse_args()
 
-logging.basicConfig(level = logging.INFO)
+logging.basicConfig(level=logging.INFO)
 
 if args.name == None or '.iso' not in args.name or args.isoroot == None:
-    print 'The usage:', sys.argv[0],  '--name release-variant-arch.iso --isoroot ~/iso_location'
+    print('The usage:', sys.argv[0],
+        '--name release-variant-arch.iso --isoroot ~/iso_location')
     sys.exit(1)
 else:
     st_name = args.name.rstrip('.iso')
@@ -68,6 +68,7 @@
 else:
     ubiquity_image = False
 
+
 class TestValidateISO(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -76,7 +77,7 @@
         except OSError:
             logging.error("Creating temp dirrectory failed")
             unittest.fail("Setup error")
-                  
+
     def setUp(self):
         self.iso_name = args.name
         self.block_size = ONE_MB_BLOCK
@@ -84,7 +85,7 @@
         self.st_release = st_release
         self.st_variant = st_variant
         self.st_arch = st_arch
-             
+
         if self.st_release != 'precise':
             self.url = DEFAULT_URL
         else:
@@ -100,7 +101,7 @@
             if self.st_release == 'precise':
                 self.url = os.path.join(DEFAULT_URL, 'ubuntu-server',
                                         'precise', 'daily')
-            else: # current dev release
+            else:  # current dev release
                 self.url = os.path.join(DEFAULT_URL, 'ubuntu-server', 'daily')
         else:
             self.fail("Image name be in the form of release-variant-arch.iso")
@@ -134,10 +135,10 @@
         sha256 = hashlib.sha256()
         with open(self.iso_location) as f:
             while True:
-               data = f.read(self.block_size)
-               if not data:
-                   break
-               sha256.update(data)
+                data = f.read(self.block_size)
+                if not data:
+                    break
+                sha256.update(data)
         sha256 = sha256.hexdigest()
         logging.debug("Expected Checksum: '%s'", iso_sha256)
         logging.debug("Local File Checksum: '%s'", sha256)
@@ -146,13 +147,13 @@
     # Test if the list file in the repository matches the content of the iso
     def test_files_list(self):
         if self.st_variant == 'server':
-            list_url = os.path.join(self.url, 'current', 
+            list_url = os.path.join(self.url, 'current',
                                     self.st_release + '-' + 'server' + '-' +
                                     self.st_arch + '.list')
         else:
-            list_url = os.path.join(self.url, 'current', 
+            list_url = os.path.join(self.url, 'current',
                                     self.st_release + '-' +
-                                    self.st_variant + '-' + 
+                                    self.st_variant + '-' +
                                     self.st_arch + '.list')
 
         try:
@@ -164,9 +165,9 @@
 
         logging.debug('Extracting list file info from ISO')
         cmd = ["bsdtar", "-tf", self.iso_location]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Checking for error in extracting the file list')
         self.assertEqual(stderr, '')
 
@@ -175,12 +176,12 @@
             self.assertIn(list_entry[1:].rstrip(), stdout)
 
     # Test if the manfest is the same as that is given in the server
-    @unittest.skipUnless(ubiquity_image, 
+    @unittest.skipUnless(ubiquity_image,
                         "manifest only for ubiquity based images")
     def test_manifest(self):
-        manifest_url = os.path.join(self.url, 'current', 
+        manifest_url = os.path.join(self.url, 'current',
                                     self.st_release + '-' +
-                                    self.st_variant + '-' + 
+                                    self.st_variant + '-' +
                                     self.st_arch + '.manifest')
         try:
             manifest = urllib2.urlopen(manifest_url)
@@ -192,9 +193,9 @@
         logging.debug('Extracting manifest from the iso')
         cmd = ["bsdtar", "-xf", self.iso_location, "-C", self.temp_dir,
                "casper/filesystem.manifest"]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting manifest info from iso')
         self.assertEqual(stderr, '')
 
@@ -212,9 +213,9 @@
         logging.debug('Extract distro information of the image from the iso')
         cmd = ["bsdtar", "-xf", self.iso_location, "-C",
                                 self.temp_dir, "./.disk/info"]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Checking for error in extracting distro info from iso')
         self.assertEqual(stderr, '')
 
@@ -240,36 +241,36 @@
             self.assertIn(id_server, build_info_line)
 
     # Test if  wubi is present for desktop or dvd and it is a valid PE
-    @unittest.skipUnless(st_variant =='desktop' and 
+    @unittest.skipUnless(st_variant == 'desktop' and
                          st_arch != 'powerpc', "Skipping non ubiquity images")
     def test_wubi(self):
         logging.debug('Extracting wubi from the desktop images')
-        cmd = ["bsdtar", "-xf", self.iso_location, "-C", 
+        cmd = ["bsdtar", "-xf", self.iso_location, "-C",
                                 self.temp_dir, "./wubi.exe"]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting wubi.exe from the iso')
         self.assertEqual(stderr, '')
 
         wubi_path = os.path.join(self.temp_dir, './wubi.exe')
 
         cmd = ["file", wubi_path]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check that wubi has a valid PE header')
         self.assertEqual(stderr, '')
         self.assertIn(" PE32 executable (GUI)", stdout)
 
     # Test if the relevant files are present in the iso for desktop iso
-    @unittest.skipUnless(st_variant == 'desktop' and 
+    @unittest.skipUnless(st_variant == 'desktop' and
                          st_arch != 'powerpc', "Skipping for non desktop iso")
     def test_files_ubiquity(self):
         cmd = ["bsdtar", "-tf", self.iso_location]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting file list from the iso')
         self.assertEqual(stderr, '')
         files_list = open("data/file_list_ubiquity")
@@ -282,9 +283,9 @@
                         "This file list test is only specific for dvd")
     def test_files_ubiquity_dvd(self):
         cmd = ["bsdtar", "-tf", self.iso_location]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting file list from the iso')
         self.assertEqual(stderr, '')
         files_list = open("data/file_list_ubiquity_dvd")
@@ -300,15 +301,15 @@
     @unittest.skipIf(ubiquity_image, "Skipping for ubiquity images")
     def test_files_di(self):
         cmd = ["bsdtar", "-tf", self.iso_location]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting file list from the iso')
         self.assertEqual(stderr, '')
 
         if self.st_arch == 'powerpc' or self.st_arch == 'amd64+mac':
             files_list = open("data/file_list_di_powerpc")
-        else: #i386 or amd64
+        else:  # i386 or amd64
             files_list = open("data/file_list_di")
 
         for list_server in files_list:
@@ -321,42 +322,43 @@
     def test_vmlinuz(self):
         cmd = ["bsdtar", "-xf", self.iso_location, "-C",
                                 self.temp_dir, "casper/vmlinuz"]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Asserting that vmlinuz is present in the iso')
         self.assertEqual(stderr, '')
 
         vmlinuz_path = os.path.join(self.temp_dir, 'casper/vmlinuz')
 
         cmd = ["file", vmlinuz_path]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check if vmlinuz present in the iso is a Linux kernel')
         self.assertEqual(stderr, '')
         self.assertIn("Linux kernel", stdout)
 
-    # Test if filesystem.squashfs is present and 
+    # Test if filesystem.squashfs is present and
     # if that is a squash fs for ubiquity based images
     @unittest.skipUnless(ubiquity_image, "Skipping for non ubiquity images")
     def test_filesystem_squashfs(self):
         logging.debug('Extracting the filesystem.squashfs')
-        cmd = ["bsdtar", "-xf" , self.iso_location, "-C",
+        cmd = ["bsdtar", "-xf", self.iso_location, "-C",
                                  self.temp_dir, "casper/filesystem.squashfs"]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check for error in extracting filesystem.squashfs')
         self.assertEqual(stderr, '')
 
-        squashfs_path = os.path.join(self.temp_dir, 'casper/filesystem.squashfs')
+        squashfs_path = os.path.join(self.temp_dir,
+            'casper/filesystem.squashfs')
 
         logging.debug('Checking the file is an actual .squashfs')
         cmd = ["file", squashfs_path]
-        output = subprocess.Popen(cmd, stdout = subprocess.PIPE,
-                                  stderr = subprocess.PIPE)
-        (stdout, stderr) = output.communicate ()
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+        (stdout, stderr) = output.communicate()
         logging.debug('Check if signature contains \"Squashfs filesystem\"')
         self.assertEqual(stderr, '')
         self.assertIn("Squashfs filesystem", stdout)
@@ -369,7 +371,7 @@
         #self.assertEqual(stderr, '')
         #self.assertIn("created 1 directories", stdout)
 
-    # Test if the report.html exists for the d-i based images 
+    # Test if the report.html exists for the d-i based images
     # and that it does not have any conflicting packages
     @unittest.skipIf(ubiquity_image, "Skipping for ubiquity based images")
     def test_report_html(self):
@@ -392,10 +394,12 @@
 
         if(self.st_release == 'precise'):
             # check if the size of the image fits a 703MB cd for precise
-            self.assertTrue(statinfo.st_size < PRECISE_SIZE_LIMIT_MB, "Size: %s" % (statinfo.st_size))
+            self.assertTrue(statinfo.st_size < PRECISE_SIZE_LIMIT_MB,
+                "Size: %s" % (statinfo.st_size))
         else:
             # check if the size of the image fits a 800MB cd for quantal
-            self.assertTrue(statinfo.st_size < QUANTAL_SIZE_LIMIT_MB, "Size: %s" % (statinfo.st_size))
+            self.assertTrue(statinfo.st_size < QUANTAL_SIZE_LIMIT_MB,
+                "Size: %s" % (statinfo.st_size))
 
     # clean up
     @classmethod