Adding ability to bisect recipe to bisect into dependency repos.

scripts/slave/recipe_modules/auto_bisect/bisector_test.py

 # Copyright 2015 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.
 
 import os
 import sys
 import unittest
 
 # TODO(robertocn): Use abspath for these, to prevent relative path errors.
 _RECIPE_MODULES_DIR = os.path.join(os.path.dirname(__file__), os.path.pardir)
 # For the importing of mock.
 _ROOT_DIR = os.path.join(os.path.dirname(__file__), os.path.pardir,
                          os.path.pardir, os.path.pardir, os.path.pardir)
 
 sys.path.append(_RECIPE_MODULES_DIR)
 sys.path.append(os.path.join(_ROOT_DIR, 'third_party', 'mock-1.0.1'))
 
 import mock
 
 from auto_bisect.bisector import Bisector
 
+# Globals
+called_abort = False
+aborted_once = False
+
 class BisectorTest(unittest.TestCase):
   def setUp(self):
     self.bisect_config = {
         'test_type': 'perf',
         'command': 'tools/perf/run_benchmark -v '
                     '--browser=release page_cycler.intl_ar_fa_he',
         'good_revision': '306475',
         'bad_revision': '306478',
         'metric': 'warm_times/page_load_time',
         'repeat_count': '2',
@@ skipping 162 matching lines @@
         r.in_progress = True
       new_bisector.revisions[0].tested = True
       finished_revision = new_bisector.wait_for_any(new_bisector.revisions)
       self.assertEqual(new_bisector.revisions[0], finished_revision)
 
   def test_abort_unnecessary_jobs(self):
     global aborted_once, called_abort
     called_abort = False
     aborted_once = False
 
-    def mock_abort(s):
+    def mock_abort(_):
       global aborted_once, called_abort
       called_abort = True
       if aborted_once:
-        raise Exception('Only one abort expected')
+        raise RuntimeError('Only one abort expected')
       aborted_once = True
 
     self.MockRevisionClass.abort = None
     self.MockRevisionClass.update_status = None
     with mock.patch(
         'bisector_test.BisectorTest.MockRevisionClass.update_status'):
       with mock.patch('bisector_test.BisectorTest.MockRevisionClass.abort',
-                      mock_abort) as abort_patch:
+                      mock_abort):
         new_bisector = Bisector(self.dummy_api, self.bisect_config,
                                 self.MockRevisionClass)
         r = new_bisector.revisions
         r[0].good = True
         r[0].bad = False
         r[0].tested = True
         r[0].in_progress = False
 
         r[1].in_progress = True
         r[1].tested = False
 
         r[2].good = True
         r[2].bad = False
         r[2].tested = True
         r[2].in_progress = False
 
         r[3].bad = True
         r[3].good = False
         r[3].tested = True
         r[3].in_progress = False
 
         try:
           new_bisector.abort_unnecessary_jobs()
-        except:
+        except RuntimeError:
           self.fail('Expected to call abort only once')
         self.assertTrue(called_abort)

[qyearsley, 2015/02/22 20:37:55]

Would it be possible to do this without global variables?

One possibility if you want to avoid global variables would be to make separate
TestCase class and make them class variables (which could be reset to False in
the setUp method). This would make it so that when reading this method, one
doesn't have to consider other possible places where these variables could be
used.

[RobertoCN, 2015/02/24 20:01:14]

Done.

 
         # Verifying the side effects of updating the candidate range
         self.assertEqual(r[2], new_bisector.lkgr)
         self.assertEqual(r[3], new_bisector.fkbr)
 
-# TODO: Test check_bisect_finished
-
-
+# TODO(robertocn): Add test for bisector.check_bisect_finished.
 if __name__ == '__main__':
   unittest.main()