Extract update_scripts out of annotated_run

scripts/slave/unittests/annotated_run_test.py

 #!/usr/bin/env python
 
 # 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.
 
 """Tests that the tools/build annotated_run wrapper actually runs."""
 
 import collections
 import contextlib
 import json
 import logging
 import os
 import subprocess
 import sys
 import tempfile
 import unittest
 
 import test_env  # pylint: disable=W0403,W0611
 
 import mock
 from common import chromium_utils
 from common import env
 from slave import annotated_run
 from slave import gce
 from slave import infra_platform
+from slave import update_scripts
 
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 
 MockOptions = collections.namedtuple('MockOptions',
     ('dry_run', 'logdog_force', 'logdog_butler_path', 'logdog_annotee_path',
      'logdog_verbose', 'logdog_service_account_json', 'logdog_pubsub_topic',
      'logdog_host'))
 
 
 class AnnotatedRunTest(unittest.TestCase):
   def test_example(self):
     build_properties = {
       'recipe': 'annotated_run_test',
       'true_prop': True,
       'num_prop': 123,
       'string_prop': '321',
       'dict_prop': {'foo': 'bar'},
     }
 
     script_path = os.path.join(BASE_DIR, 'annotated_run.py')
     exit_code = subprocess.call([
         'python', script_path,
         '--build-properties=%s' % json.dumps(build_properties)])
     self.assertEqual(exit_code, 0)
 
+  @mock.patch('slave.update_scripts._run_command')
   @mock.patch('slave.annotated_run._run_command')
   @mock.patch('slave.annotated_run.main')
   @mock.patch('sys.platform', return_value='win')
   @mock.patch('tempfile.mkstemp', side_effect=Exception('failure'))
   @mock.patch('os.environ', {})
   def test_update_scripts_must_run(self, _tempfile_mkstemp, _sys_platform,
-                                   main, run_command):
+                                   main, annotated_run_command,
+                                   update_scripts_run_command):
+    update_scripts._run_command.return_value = (0, "")
+    annotated_run._run_command.return_value = (0, "")
     annotated_run.main.side_effect = Exception('Test error!')
-    annotated_run._run_command.return_value = (0, "")
     annotated_run.shell_main(['annotated_run.py', 'foo'])
 
     gclient_path = os.path.join(env.Build, os.pardir, 'depot_tools',
                                 'gclient.bat')
-    run_command.assert_has_calls([
+    annotated_run_command.assert_has_calls([
+        mock.call([sys.executable, 'annotated_run.py', 'foo']),
+        ])
+    update_scripts_run_command.assert_has_calls([
         mock.call([gclient_path, 'sync', '--force', '--verbose', '--jobs=2',
                    '--break_repo_locks'],
                   cwd=env.Build),
-        mock.call([sys.executable, 'annotated_run.py', 'foo']),
         ])
     main.assert_not_called()
 
 
 class _AnnotatedRunExecTestBase(unittest.TestCase):
   def setUp(self):
     logging.basicConfig(level=logging.ERROR+1)
 
     self.maxDiff = None
     self._patchers = []
@@ skipping 304 matching lines @@
 
   def test_will_not_bootstrap_if_recursive(self):
     os.environ['LOGDOG_STREAM_PREFIX'] = 'foo'
     self.assertRaises(annotated_run.LogDogNotBootstrapped,
         annotated_run._logdog_bootstrap, self.rt, self.opts, self.basedir,
         self.tdir, self._config(), self.properties, [])
 
 
 if __name__ == '__main__':
   unittest.main()