Refactored bisect results dicts into a separate class

tools/auto_bisect/bisect_perf_regression_test.py

 # Copyright 2014 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 re
 import shutil
 import unittest
 
 import bisect_perf_regression
+import bisect_results
 import source_control as source_control_module
 
 
 def _GetBisectPerformanceMetricsInstance():
   """Returns an instance of the BisectPerformanceMetrics class."""
   options_dict = {
     'debug_ignore_build': True,
     'debug_ignore_sync': True,
     'debug_ignore_perf_test': True,
     'command': 'fake_command',
     'metric': 'fake/metric',
     'good_revision': 280000,
     'bad_revision': 280005,
   }
   bisect_options = bisect_perf_regression.BisectOptions.FromDict(options_dict)
   source_control = source_control_module.DetermineAndCreateSourceControl(
       bisect_options)
   bisect_instance = bisect_perf_regression.BisectPerformanceMetrics(
       source_control, bisect_options)
   return bisect_instance
 
 
 class BisectPerfRegressionTest(unittest.TestCase):
   """Test case for other functions and classes in bisect-perf-regression.py."""
 
+  def setUp(self):
+    self.cwd = os.getcwd()
+
+  def tearDown(self):
+    os.chdir(self.cwd)
+
   def _AssertConfidence(self, score, bad_values, good_values):
     """Checks whether the given sets of values have a given confidence score.
 
     The score represents our confidence that the two sets of values wouldn't
     be as different as they are just by chance; that is, that some real change
     occurred between the two sets of values.
 
     Args:
       score: Expected confidence score.
       bad_values: First list of numbers.
       good_values: Second list of numbers.
     """
     # ConfidenceScore takes a list of lists but these lists are flattened
     # inside the function.
-    confidence = bisect_perf_regression.ConfidenceScore(
+    confidence = bisect_results.ConfidenceScore(
         [[v] for v in bad_values],
         [[v] for v in good_values])
     self.assertEqual(score, confidence)
 
   def testConfidenceScore_ZeroConfidence(self):
     # The good and bad sets contain the same values, so the confidence that
     # they're different should be zero.
     self._AssertConfidence(0.0, [4, 5, 7, 6, 8, 7], [8, 7, 6, 7, 5, 4])
 
   def testConfidenceScore_MediumConfidence(self):
@@ skipping 221 matching lines @@
     bisect_instance = _GetBisectPerformanceMetricsInstance()
     wk_rev = 'a94d028e0f2c77f159b3dac95eb90c3b4cf48c61'
     depot_path = os.path.join(bisect_perf_regression.SRC_DIR, 'third_party',
                               'WebKit')
     self.assertEqual(
         181660,
         bisect_instance.source_control.GetCommitPosition(wk_rev, depot_path))
 
   def testUpdateDepsContent(self):
     bisect_instance = _GetBisectPerformanceMetricsInstance()
-    deps_file = 'DEPS'
+    deps_file = os.path.join(bisect_perf_regression.SRC_DIR, 'DEPS')
     # We are intentionally reading DEPS file contents instead of string literal
     # with few lines from DEPS because to check if the format we are expecting
     # to search is not changed in DEPS content.
     # TODO (prasadv): Add a separate test to validate the DEPS contents with the
     # format that bisect script expects.
     deps_contents = bisect_perf_regression.ReadStringFromFile(deps_file)
     deps_key = 'v8_revision'
     depot = 'v8'
     git_revision = 'a12345789a23456789a123456789a123456789'
     updated_content = bisect_instance.UpdateDepsContents(
         deps_contents, depot, git_revision, deps_key)
     self.assertIsNotNone(updated_content)
     ss = re.compile('["\']%s["\']: ["\']%s["\']' % (deps_key, git_revision))
     self.assertIsNotNone(re.search(ss, updated_content))
 
 
+class DepotDirectoryRegistryTest(unittest.TestCase):
+
+  def setUp(self):
+    self.old_src_dir = bisect_perf_regression.SRC_DIR
+    bisect_perf_regression.SRC_DIR = '/mock/src'
+    self.old_chdir = os.chdir
+    os.chdir = self.mockChdir
+    self.old_depot_names = bisect_perf_regression.DEPOT_NAMES
+    bisect_perf_regression.DEPOT_NAMES = ['mock_depot']
+    self.old_depot_deps_name = bisect_perf_regression.DEPOT_DEPS_NAME
+    bisect_perf_regression.DEPOT_DEPS_NAME = {'mock_depot': {'src': 'src/foo'}}
+
+    self.registry = bisect_perf_regression.DepotDirectoryRegistry()
+    self.cur_dir = None
+
+  def tearDown(self):
+    bisect_perf_regression.SRC_DIR = self.old_src_dir
+    os.chdir = self.old_chdir
+    bisect_perf_regression.DEPOT_NAMES = self.old_depot_names
+    bisect_perf_regression.DEPOT_DEPS_NAME = self.old_depot_deps_name
+
+  def mockChdir(self, new_dir):
+    self.cur_dir = new_dir
+
+  def testReturnsCorrectResultForChrome(self):
+    self.assertEqual(self.registry.GetDepotDir('chromium'), '/mock/src')
+
+  def testReturnsCorrectResultForChromeOS(self):
+    self.assertEqual(self.registry.GetDepotDir('cros'), '/mock/src/tools/cros')
+
+  def testUsesDepotSpecToInitializeRegistry(self):
+    self.assertEqual(self.registry.GetDepotDir('mock_depot'), '/mock/src/foo')
+
+  def testChangedTheDirectory(self):
+    self.registry.ChangeToDepotDir('mock_depot')
+    self.assertEqual(self.cur_dir, '/mock/src/foo')
+
+
 if __name__ == '__main__':
   unittest.main()