Adding ability to bisect recipe to bisect into dependency repos.

scripts/slave/recipe_modules/auto_bisect/bisector_test.py

Index: scripts/slave/recipe_modules/auto_bisect/bisector_test.py
diff --git a/scripts/slave/recipe_modules/auto_bisect/bisector_test.py b/scripts/slave/recipe_modules/auto_bisect/bisector_test.py
index d8b483961674ae9516a977971b92c80a65f417ce..e63ba116ac8d95ca77cd308b5bbac3a93dc29a06 100644
--- a/scripts/slave/recipe_modules/auto_bisect/bisector_test.py
+++ b/scripts/slave/recipe_modules/auto_bisect/bisector_test.py
@@ -19,6 +19,22 @@ import mock
 
 from auto_bisect.bisector import Bisector
 
+
+class MockRevisionClass(object):
+  def __init__(self, rev_string, bisector):
+    self.commit_pos = int(rev_string)
+    self.revision_string = rev_string
+    self.bisector = bisector
+    self.previous_revision = None
+    self.next_revision = None
+    self.values = []
+
+  def get_next_url(self):
+    if self.in_progress:
+      return 'mockurl'
+    return None
+
+
 class BisectorTest(unittest.TestCase):
   def setUp(self):
     self.bisect_config = {
@@ -39,23 +55,11 @@ class BisectorTest(unittest.TestCase):
     }
     self.dummy_api = mock.Mock()
 
-  class MockRevisionClass(object):
-    def __init__(self, rev_string, bisector):
-      self.commit_pos = int(rev_string)
-      self.revision_string = rev_string
-      self.bisector = bisector
-      self.previous_revision = None
-      self.next_revision = None
-      self.values = []
 
-    def get_next_url(self):
-      if self.in_progress:
-        return 'mockurl'
-      return None
 
   def test_create_bisector(self):
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     # Check the proper revision range is initialized
     self.assertEqual(4, len(new_bisector.revisions))
     a, b, c, d = new_bisector.revisions
@@ -78,14 +82,14 @@ class BisectorTest(unittest.TestCase):
   def test_improvement_direction_default(self):
     # By default, no improvement direction should be set
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertIsNone(new_bisector.improvement_direction)
 
   def test_improvement_direction_greater_is_better(self):
     # Improvement up, bad > good: should fail
     self.bisect_config['improvement_direction'] = 1
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     new_bisector.good_rev.mean_value = 10
     new_bisector.bad_rev.mean_value = 100
     self.assertFalse(new_bisector.check_improvement_direction())
@@ -94,7 +98,7 @@ class BisectorTest(unittest.TestCase):
     # Improvement up, bad < good: should not fail
     self.bisect_config['improvement_direction'] = 1
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     new_bisector.good_rev.mean_value = 100
     new_bisector.bad_rev.mean_value = 10
     self.assertTrue(new_bisector.check_improvement_direction())
@@ -104,7 +108,7 @@ class BisectorTest(unittest.TestCase):
     # Improvement down, bad < good: should fail
     self.bisect_config['improvement_direction'] = -1
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     new_bisector.good_rev.mean_value = 100
     new_bisector.bad_rev.mean_value = 10
     self.assertFalse(new_bisector.check_improvement_direction())
@@ -113,7 +117,7 @@ class BisectorTest(unittest.TestCase):
     # Improvement down, bad > good: should not fail
     self.bisect_config['improvement_direction'] = -1
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     new_bisector.good_rev.mean_value = 10
     new_bisector.bad_rev.mean_value = 100
     self.assertTrue(new_bisector.check_improvement_direction())
@@ -125,14 +129,14 @@ class BisectorTest(unittest.TestCase):
     # A confidence score of 0 should not satisfy any default
     mock_score.return_value = 0
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertFalse(new_bisector.check_regression_confidence())
     self.assertTrue(new_bisector.failed_confidence)
 
     # A confidence score of 100 should satisfy any default
     mock_score.return_value = 100
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertTrue(new_bisector.check_regression_confidence())
     self.assertFalse(new_bisector.failed_confidence)
 
@@ -141,7 +145,7 @@ class BisectorTest(unittest.TestCase):
     mock_score = self.dummy_api.m.math_utils.confidence_score
     self.bisect_config['required_regression_confidence'] = None
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertTrue(new_bisector.check_regression_confidence())
     self.assertFalse(mock_score.called)
 
@@ -151,14 +155,14 @@ class BisectorTest(unittest.TestCase):
     # A confidence score of 98.5 should not satisfy the required 99
     mock_score.return_value = 98.5
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertFalse(new_bisector.check_regression_confidence())
     self.assertTrue(new_bisector.failed_confidence)
 
     # A confidence score of 99.5 should satisfy the required 99
     mock_score.return_value = 99.5
     new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                            self.MockRevisionClass)
+                            MockRevisionClass)
     self.assertTrue(new_bisector.check_regression_confidence())
     self.assertFalse(new_bisector.failed_confidence)
 
@@ -172,10 +176,10 @@ class BisectorTest(unittest.TestCase):
 
     # Plug in mock update_status method
     with mock.patch(
-        'bisector_test.BisectorTest.MockRevisionClass.update_status',
+        'bisector_test.MockRevisionClass.update_status',
         mock_update_status):
       new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                              self.MockRevisionClass)
+                              MockRevisionClass)
       for r in new_bisector.revisions:
         r.in_progress = True
       new_bisector.wait_for_all(new_bisector.revisions)
@@ -184,11 +188,11 @@ class BisectorTest(unittest.TestCase):
 
   def test_wait_for_any(self):
     # Creating placeholder for the patch
-    self.MockRevisionClass.update_status = None
+    MockRevisionClass.update_status = None
     with mock.patch(
-        'bisector_test.BisectorTest.MockRevisionClass.update_status'):
+        'bisector_test.MockRevisionClass.update_status'):
       new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                              self.MockRevisionClass)
+                              MockRevisionClass)
       for r in new_bisector.revisions:
         r.tested = False
         r.in_progress = True
@@ -196,26 +200,44 @@ class BisectorTest(unittest.TestCase):
       finished_revision = new_bisector.wait_for_any(new_bisector.revisions)
       self.assertEqual(new_bisector.revisions[0], finished_revision)
 
+
+class BisectorAbortTest(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',
+        'max_time_minutes': '5',
+        'truncate_percent': '25',
+        'bug_id': '425582',
+        'gs_bucket': 'chrome-perf',
+        'builder_host': 'master4.golo.chromium.org',
+        'builder_port': '8341',
+        'dummy_builds': True,
+    }
+    self.dummy_api = mock.Mock()
+    self.called_abort = False
+    self.aborted_once = False
+
   def test_abort_unnecessary_jobs(self):
-    global aborted_once, called_abort
-    called_abort = False
-    aborted_once = False
-
-    def mock_abort(s):
-      global aborted_once, called_abort
-      called_abort = True
-      if aborted_once:
-        raise Exception('Only one abort expected')
-      aborted_once = True
-
-    self.MockRevisionClass.abort = None
-    self.MockRevisionClass.update_status = None
+    def mock_abort(_):
+      self.called_abort = True
+      if self.aborted_once:
+        raise RuntimeError('Only one abort expected')
+      self.aborted_once = True
+
+    MockRevisionClass.abort = None
+    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:
+        'bisector_test.MockRevisionClass.update_status'):
+      with mock.patch('bisector_test.MockRevisionClass.abort',
+                      mock_abort):
         new_bisector = Bisector(self.dummy_api, self.bisect_config,
-                                self.MockRevisionClass)
+                                MockRevisionClass)
         r = new_bisector.revisions
         r[0].good = True
         r[0].bad = False
@@ -237,16 +259,14 @@ class BisectorTest(unittest.TestCase):
 
         try:
           new_bisector.abort_unnecessary_jobs()
-        except:
+        except RuntimeError:
           self.fail('Expected to call abort only once')
-        self.assertTrue(called_abort)
+        self.assertTrue(self.called_abort)
 
         # 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()