Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/common/net/buildbot/buildbot_unittest.py

 # Copyright (C) 2009 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #    * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 18 matching lines @@
 import unittest
 
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.net.buildbot import BuildBot, Builder, Build
 from webkitpy.layout_tests.models import test_results
 from webkitpy.layout_tests.models import test_failures
 from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup
 
 
 class BuilderTest(unittest.TestCase):
+
     def _mock_test_result(self, testname):
         return test_results.TestResult(testname, [test_failures.FailureTextMismatch()])
 
     def _install_fetch_build(self, failure):
         def _mock_fetch_build(build_number):
             build = Build(
                 builder=self.builder,
                 build_number=build_number,
                 revision=build_number + 1000,
                 is_green=build_number < 4
             )
             return build
         self.builder._fetch_build = _mock_fetch_build
 
     def setUp(self):
         self.buildbot = BuildBot()
         self.builder = Builder(u"Test Builder \u2661", self.buildbot)
         self._install_fetch_build(lambda build_number: ["test1", "test2"])
 
     def test_latest_layout_test_results(self):
         self.builder.fetch_layout_test_results = lambda results_url: LayoutTestResults(None)
         self.builder.accumulated_results_url = lambda: "http://dummy_url.org"
         self.assertTrue(self.builder.latest_layout_test_results())
 
     def test_build_caching(self):
         self.assertEqual(self.builder.build(10), self.builder.build(10))
 
     def test_build_and_revision_for_filename(self):
         expectations = {
-            "r47483 (1)/" : (47483, 1),
-            "r47483 (1).zip" : (47483, 1),
+            "r47483 (1)/": (47483, 1),
+            "r47483 (1).zip": (47483, 1),
             "random junk": None,
         }
         for filename, revision_and_build in expectations.items():
             self.assertEqual(self.builder._revision_and_build_for_filename(filename), revision_and_build)
 
     def test_file_info_list_to_revision_to_build_list(self):
         file_info_list = [
             {"filename": "r47483 (1)/"},
             {"filename": "r47483 (1).zip"},
             {"filename": "random junk"},
         ]
         builds_and_revisions_list = [(47483, 1), (47483, 1)]
         self.assertEqual(self.builder._file_info_list_to_revision_to_build_list(file_info_list), builds_and_revisions_list)
 
     def test_fetch_build(self):
         buildbot = BuildBot()
         builder = Builder(u"Test Builder \u2661", buildbot)
 
         def mock_fetch_build_dictionary(self, build_number):
             build_dictionary = {
                 "sourceStamp": {
                     "revision": None,  # revision=None means a trunk build started from the force-build button on the builder page.
-                    },
+                },
                 "number": int(build_number),
                 # Intentionally missing the 'results' key, meaning it's a "pass" build.
             }
             return build_dictionary
         buildbot._fetch_build_dictionary = mock_fetch_build_dictionary
         self.assertIsNotNone(builder._fetch_build(1))
 
     def test_results_url(self):
         builder = BuildBot().builder_with_name('WebKit Mac10.8 (dbg)')
         self.assertEqual(builder.results_url(),
@@ skipping 23 matching lines @@
       <td align="center" class="Activity idle">idle<br />3 pending</td>
     <tr>
     <td class="box"><a href="builders/Qt%20Windows%2032-bit%20Debug">Qt Windows 32-bit Debug</a></td>
       <td align="center" class="LastBuild box failure"><a href="builders/Qt%20Windows%2032-bit%20Debug/builds/2090">60563</a><br />failed<br />failed<br />slave<br />lost</td>
       <td align="center" class="Activity building">building<br />ETA in<br />~ 5 mins<br />at 08:25</td>
     </table>
 '''
     _expected_example_one_box_parsings = [
         {
             'is_green': True,
-            'build_number' : 3693,
+            'build_number': 3693,
             'name': u'Windows Debug (Tests)',
             'built_revision': 47380,
             'activity': 'building',
             'pending_builds': 0,
         },
         {
             'is_green': False,
-            'build_number' : None,
+            'build_number': None,
             'name': u'SnowLeopard Intel Release',
             'built_revision': None,
             'activity': 'building',
             'pending_builds': 0,
         },
         {
             'is_green': False,
-            'build_number' : 654,
+            'build_number': 654,
             'name': u'Qt Linux Release',
             'built_revision': 47383,
             'activity': 'idle',
             'pending_builds': 3,
         },
         {
             'is_green': True,
-            'build_number' : 2090,
+            'build_number': 2090,
             'name': u'Qt Windows 32-bit Debug',
             'built_revision': 60563,
             'activity': 'building',
             'pending_builds': 0,
         },
     ]
 
     def test_status_parsing(self):
         buildbot = BuildBot()
 
         soup = BeautifulSoup(self._example_one_box_status)
         status_table = soup.find("table")
         input_rows = status_table.findAll('tr')
 
         for x in range(len(input_rows)):
             status_row = input_rows[x]
             expected_parsing = self._expected_example_one_box_parsings[x]
 
             builder = buildbot._parse_builder_status_from_row(status_row)
 
             # Make sure we aren't parsing more or less than we expect
             self.assertEqual(builder.keys(), expected_parsing.keys())
 
             for key, expected_value in expected_parsing.items():
-                self.assertEqual(builder[key], expected_value, ("Builder %d parse failure for key: %s: Actual='%s' Expected='%s'" % (x, key, builder[key], expected_value)))
+                self.assertEqual(builder[key], expected_value, ("Builder %d parse failure for key: %s: Actual='%s' Expected='%s'" % (
+                    x, key, builder[key], expected_value)))
 
     def test_builder_with_name(self):
         buildbot = BuildBot()
 
         builder = buildbot.builder_with_name("Test Builder")
         self.assertEqual(builder.name(), "Test Builder")
         self.assertEqual(builder.url(), "http://build.chromium.org/p/chromium.webkit/builders/Test%20Builder")
         self.assertEqual(builder.url_encoded_name(), "Test%20Builder")
         self.assertEqual(builder.results_url(), "https://storage.googleapis.com/chromium-layout-test-archives/Test_Builder")
 
         # Override _fetch_build_dictionary function to not touch the network.
         def mock_fetch_build_dictionary(self, build_number):
             build_dictionary = {
                 "sourceStamp": {
-                    "revision" : 2 * build_number,
-                    },
-                "number" : int(build_number),
-                "results" : build_number % 2, # 0 means pass
+                    "revision": 2 * build_number,
+                },
+                "number": int(build_number),
+                "results": build_number % 2,  # 0 means pass
             }
             return build_dictionary
         buildbot._fetch_build_dictionary = mock_fetch_build_dictionary
 
         build = builder.build(10)
         self.assertEqual(build.builder(), builder)
         self.assertEqual(build.url(), "http://build.chromium.org/p/chromium.webkit/builders/Test%20Builder/builds/10")
         self.assertEqual(build.results_url(), "https://storage.googleapis.com/chromium-layout-test-archives/Test_Builder/r20%20%2810%29")
         self.assertEqual(build.revision(), 20)
         self.assertTrue(build.is_green())
@@ skipping 25 matching lines @@
 </tr>
 <tr class="file alt">
     <td><a href="r47484%20%282%29.zip">r47484 (2).zip</a></td>
     <td>89K</td>
     <td>[application/zip]</td>
     <td></td>
 </tr>
 '''
     _expected_files = [
         {
-            "filename" : "r47483 (1)/",
-            "size" : "",
-            "type" : "[Directory]",
-            "encoding" : "",
+            "filename": "r47483 (1)/",
+            "size": "",
+            "type": "[Directory]",
+            "encoding": "",
         },
         {
-            "filename" : "r47484 (2).zip",
-            "size" : "89K",
-            "type" : "[application/zip]",
-            "encoding" : "",
+            "filename": "r47484 (2).zip",
+            "size": "89K",
+            "type": "[application/zip]",
+            "encoding": "",
         },
     ]
 
     def test_parse_build_to_revision_map(self):
         buildbot = BuildBot()
         files = buildbot._parse_twisted_directory_listing(self._example_directory_listing)
         self.assertEqual(self._expected_files, files)
 
     _fake_builder_page = '''
     <body>
@@ skipping 64 matching lines @@
         <td class="failure">failure</td>
       </tr>
     </table>
     </body>'''
 
     def test_revisions_for_builder(self):
         buildbot = BuildBot()
         buildbot._fetch_builder_page = lambda builder: builder.page
         builder_with_success = Builder('Some builder', None)
         builder_with_success.page = self._fake_builder_page
-        self.assertEqual(buildbot._revisions_for_builder(builder_with_success), [(104643, False), (104636, False), (104635, True), (104633, False)])
+        self.assertEqual(buildbot._revisions_for_builder(builder_with_success), [
+                         (104643, False), (104636, False), (104635, True), (104633, False)])
 
         builder_without_success = Builder('Some builder', None)
         builder_without_success.page = self._fake_builder_page_without_success
-        self.assertEqual(buildbot._revisions_for_builder(builder_without_success), [(104643, False), (104636, False), (104635, False), (104633, False)])
+        self.assertEqual(buildbot._revisions_for_builder(builder_without_success), [
+                         (104643, False), (104636, False), (104635, False), (104633, False)])
 
     def test_find_green_revision(self):
         buildbot = BuildBot()
         self.assertEqual(buildbot._find_green_revision({
             'Builder 1': [(1, True), (3, True)],
             'Builder 2': [(1, True), (3, False)],
             'Builder 3': [(1, True), (3, True)],
         }), 1)
         self.assertEqual(buildbot._find_green_revision({
             'Builder 1': [(1, False), (3, True)],
@@ skipping 55 matching lines @@
         b._fetch_revision_to_build_map = self._fetch_revision_to_build_map
         self.assertEqual("correct build", b.latest_cached_build())
 
     def results_url(self):
         return "some-url"
 
     def test_results_zip_url(self):
         b = Build(None, 123, 123, False)
         b.results_url = self.results_url
         self.assertEqual("some-url.zip", b.results_zip_url())