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 ddfc2690fcf65b46db139088e2a0be37e33be9b6..aba2091ab01ddf26ab36ee5a697bc693b493f27c 100644
--- a/scripts/slave/recipe_modules/auto_bisect/bisector_test.py
+++ b/scripts/slave/recipe_modules/auto_bisect/bisector_test.py
@@ -19,7 +19,23 @@ import mock
 
 from auto_bisect.bisector import Bisector
 
-class BisectorTest(unittest.TestCase):  # pragma: no cover
+
+class MockRevisionClass(object): # pragma: no cover
+  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): # pragma: no cover

[qyearsley, 2015/03/10 23:20:48]

Nit: Two spaces before #.

[RobertoCN, 2015/03/13 20:55:59]

Done.

   def setUp(self):
     self.bisect_config = {
         'test_type': 'perf',
@@ -39,23 +55,11 @@ class BisectorTest(unittest.TestCase):  # pragma: no cover
     }
     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):  # pragma: no cover
   def test_improvement_direction_default(self):
     # By default, no improvement direction should be set
     new_bisector = Bisector(self.dummy_api, self.bisect_config,

[qyearsley, 2015/03/10 23:20:48]

If new_bisector is renamed to bisector, then MockRevisionClass fits on this
line. Same for all the lines below, I think.

[RobertoCN, 2015/03/13 20:55:59]

Done.

-                            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):  # pragma: no cover
     # 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):  # pragma: no cover
     # 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):  # pragma: no cover
     # 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):  # pragma: no cover
     # 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):  # pragma: no cover
     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):  # pragma: no cover
     # 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):  # pragma: no cover
 
     # 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):  # pragma: no cover
 
   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):  # pragma: no cover
       finished_revision = new_bisector.wait_for_any(new_bisector.revisions)
       self.assertEqual(new_bisector.revisions[0], finished_revision)
 
+
+class BisectorAbortTest(unittest.TestCase): # pragma: no cover

[qyearsley, 2015/03/10 23:20:48]

Nit: Two spaces before #.
Also, it seems strange that a test case class would need a "no cover" pragma.
All of these lines should be run when "the tests" are run. Are these tests not
included when calculating the coverage?

[RobertoCN, 2015/03/13 20:55:59]

These tests are not covered when calculating coverage. Presubmit and recipe
simulation test work specifically by ensuring that GenTests for each recipe
cover the code. It would be odd if GenTests somehow triggered these unittests.

+  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):  # pragma: no cover
 
         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.

[qyearsley, 2015/03/10 23:20:48]

Probably want two blank lines between the test case class above and the next
non-blank line.

[RobertoCN, 2015/03/13 20:55:59]

Done.

 if __name__ == '__main__':
   unittest.main()  # pragma: no cover