Adds a new unit tests for layout tests formatting script....

webkit/tools/layout_tests/layout_package/failure_finder.py

 # Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # TODO(gwilson): 1.  Change text differs to use external utils.
 #                2.  Change text_expectations parsing to existing
 #                    logic in layout_pagckage.test_expectations.
 import google.path_utils
 import difflib
 import errno
@@ skipping 163 matching lines @@
   def __init__(self,
                build,
                builder_name,
                exclude_known_failures,
                test_regex,
                output_dir,
                max_failures,
                verbose):
     self.build = build
     # TODO(gwilson): add full url-encoding for the platform.
-    self.platform = builder_name.replace(" ", "%20")
+    self.SetPlatform(builder_name)
     self.exclude_known_failures = exclude_known_failures
     self.test_regex = test_regex
     self.output_dir = output_dir
     self.max_failures = max_failures
     self.verbose = verbose
     self.fyi_builder = False
     self._flaky_test_cache = {}
     self._test_expectations_cache = None
+    # If true, scraping will still happen but no files will be downloaded.
+    self.dont_download = False
+
+  def SetPlatform(self, platform):
+    self.platform = platform.replace(" ", "%20")
 
   # TODO(gwilson): Change this to get the last build that finished
   # successfully.
   def GetLastBuild(self):
     """
     Returns the last build number for this platform.
     If use_fyi is true, this only looks at the fyi builder.
     """
     try:
       return ExtractSingleRegexAtURL(GetBuilderURL(self.platform,
                                                    self.fyi_builder),
                                      LAST_BUILD_REGEX)
     except urllib2.HTTPError:
       if not self.fyi_builder:
         self.fyi_builder = True
         return self.GetLastBuild()
 
   def GetFailures(self):
     if not self.build:
       self.build = self.GetLastBuild()
     if self.verbose:
       print "Using build number %s" % self.build
 
     self.failures = self._GetFailuresFromBuilder()
-    if self.failures and self._DownloadResultResources():
+    if (self.failures and
+        (self._DownloadResultResources() or self.dont_download)):
       return self.failures
     return None
 
   def _GetFailuresFromBuilder(self):
     """
     Returns a list of failures for the given build and platform by scraping
     the buildbots and parsing their results.
     The list returned contains Failure class objects.
     """
     if self.verbose:
@@ skipping 78 matching lines @@
           matches.append(failure)
     return matches
 
   # TODO(gwilson): add support for multiple conflicting build numbers by
   # renaming the zip file and naming the directory appropriately.
   def _DownloadResultResources(self):
     """
     Finds and downloads/extracts all of the test results (pixel/text output)
     for all of the given failures.
     """
-    content = ScrapeURL(GetArchiveURL(self.build,
-                                      self.platform,
-                                      self.fyi_builder))
-    revision = ExtractFirstValue(content, ARCHIVE_URL_REGEX)
-    build_name = ExtractFirstValue(content, BUILD_NAME_REGEX)
+    revision, build_name = self._GetRevisionAndBuildFromArchiveStep()
 
     target_zip = "%s/layout-test-results-%s.zip" % (self.output_dir,
                                                     self.build)
     zip_url = GetZipFileURL(revision, build_name)
     if self.verbose:
       print "Downloading zip file from %s to %s" % (zip_url, target_zip)
     filename = self._DownloadFile(zip_url, target_zip, "b")
     if not filename:
-      print "Could not download zip file from %s.  Does it exist?" % zip_url
+      if self.verbose:
+        print "Could not download zip file from %s.  Does it exist?" % zip_url
       return False
 
     if zipfile.is_zipfile(filename):
       zip = zipfile.ZipFile(filename)
       if self.verbose:
         print 'Extracting files...'
       directory = "%s/layout-test-results-%s" % (self.output_dir, self.build)
       CreateDirectory(directory)
       for failure in self.failures:
         if failure.text_diff_mismatch or failure.simplified_text_diff_mismatch:
           self._PopulateTextFailure(failure, directory, zip)
         if failure.image_mismatch:
           self._PopulateImageFailure(failure, directory, zip)
         failure.test_age = self._GetFileAge(failure.GetTestHome())
         failure.flakiness = self._GetFlakiness(failure.test_path, self.platform)
         failure.test_expectations_line = (
           self._GetTestExpectationsLine(failure.test_path, self.platform))
       zip.close()
       if self.verbose:
         print "Files extracted."
         print "Deleting zip file..."
       os.remove(filename)
       return True
     else:
-      print "Downloaded file '%s' doesn't look like a zip file." % filename
+      if self.verbose:
+        print "Downloaded file '%s' doesn't look like a zip file." % filename
       return False
 
+  def _GetRevisionAndBuildFromArchiveStep(self):
+    content = ScrapeURL(GetArchiveURL(self.build,
+                                      self.platform,
+                                      self.fyi_builder))
+    revision = ExtractFirstValue(content, ARCHIVE_URL_REGEX)
+    build_name = ExtractFirstValue(content, BUILD_NAME_REGEX)
+    return (revision, build_name)
+
   def _PopulateTextFailure(self, failure, directory, zip):
     baselines = self._GetBaseline(failure.GetExpectedTextFilename(),
                                   directory)
     failure.text_baseline_local = baselines[0]
     failure.text_baseline_url = baselines[1]
     failure.text_baseline_age = (
       self._GetFileAge(failure.GetTextBaselineTracHome()))
     failure.text_actual_local = "%s/%s" % (directory,
                                            failure.GetActualTextFilename())
-    if self._ExtractFileFromZip(zip,
-                                failure.GetTextResultLocationInZipFile(),
-                                failure.text_actual_local):
+    if (not self.dont_download and
+        self._ExtractFileFromZip(zip,
+                                 failure.GetTextResultLocationInZipFile(),
+                                 failure.text_actual_local)):
       GenerateTextDiff(failure.text_baseline_local,
                        failure.text_actual_local,
                        directory + "/" + failure.GetTextDiffFilename())
 
   def _PopulateImageFailure(self, failure, directory, zip):
     baselines = self._GetBaseline(failure.GetExpectedImageFilename(),
                                    directory)
     failure.image_baseline_local = baselines[0]
     failure.image_baseline_url = baselines[1]
     if baselines[0] and baselines[1]:
       failure.image_baseline_age = (
         self._GetFileAge(failure.GetImageBaselineTracHome()))
       failure.image_actual_local = "%s/%s" % (directory,
                                    failure.GetActualImageFilename())
       self._ExtractFileFromZip(zip,
                                failure.GetImageResultLocationInZipFile(),
                                failure.image_actual_local)
-      if not GeneratePNGDiff("./" + failure.image_baseline_local,
+      if (not GeneratePNGDiff("./" + failure.image_baseline_local,
                              "./" + failure.image_actual_local,
                              "./%s/%s" %
-                             (directory, failure.GetImageDiffFilename())):
+                             (directory, failure.GetImageDiffFilename()))
+          and self.verbose):
         print "Could not generate PNG diff for %s" % failure.test_path
       if failure.IsImageBaselineInChromium():
         upstream_baselines = (
           self._GetUpstreamBaseline(failure.GetExpectedImageFilename(),
                                     directory))
         failure.image_baseline_upstream_local = upstream_baselines[0]
         failure.image_baseline_upstream_url = upstream_baselines[1]
 
   def _GetBaseline(self, filename, directory, upstream_only = False):
     """
@@ skipping 12 matching lines @@
     if upstream_only:
       last_index = local_filename.rfind(".")
       if last_index > -1:
         local_filename = (local_filename[0:last_index] +
                           UPSTREAM_IMAGE_FILE_ENDING)
 
     download_file_modifiers = ""
     if local_filename.endswith(".png"):
       download_file_modifiers = "b"  # binary file
 
-    CreateDirectory(local_filename[0:local_filename.rfind("/")])
+    if not self.dont_download:
+      CreateDirectory(local_filename[0:local_filename.rfind("/")])
 
     webkit_mac_location = (
       self._MangleWebkitPixelTestLocation(WEBKIT_IMAGE_BASELINE_BASE_URL_MAC,
                                            filename))
     webkit_win_location = (
       self._MangleWebkitPixelTestLocation(WEBKIT_IMAGE_BASELINE_BASE_URL_WIN,
                                            filename))
 
     possible_files = []
 
@@ skipping 53 matching lines @@
   def _GetFileAge(self, url):
     try:
       if url.find(WEBKIT_TRAC_HOSTNAME) > -1:
         return ExtractSingleRegexAtURL(url[:url.rfind("/")],
                                        WEBKIT_FILE_AGE_REGEX %
                                        url[url.find("/browser"):])
       else:
         return ExtractSingleRegexAtURL(url + "?view=log",
                                        CHROMIUM_FILE_AGE_REGEX)
     except:
-      print "Could not find age for %s. Does the file exist?" % url
+      if self.verbose:
+        print "Could not find age for %s. Does the file exist?" % url
       return None
 
   # Returns a flakiness on a scale of 1-50.
   # TODO(gwilson): modify this to also return which of the last 10 builds failed
   # for this test.
   def _GetFlakiness(self, test_path, target_platform):
     url = GetFlakyTestURL(target_platform)
     if url == "":
       return None
 
@@ skipping 59 matching lines @@
   def _DownloadFile(self, url, local_filename = None, modifiers = "",
                     force = False):
     """
     Copy the contents of a file from a given URL
     to a local file.
     """
     try:
       if local_filename == None:
         local_filename = url.split('/')[-1]
       if os.path.isfile(local_filename) and not force:
-        print "File at %s already exists." % local_filename
+        if self.verbose:
+          print "File at %s already exists." % local_filename
+        return local_filename
+      if self.dont_download:
         return local_filename
       webFile = urllib2.urlopen(url)
       localFile = open(local_filename, ("w%s" % modifiers))
       localFile.write(webFile.read())
       webFile.close()
       localFile.close()
     except urllib2.HTTPError:
       return None
     except urllib2.URLError:
       print "The url %s is malformed." % url
       return None
     return localFile.name