git cl try-results: add --wait-till-finished option.

tests/git_cl_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Unit tests for git_cl.py."""
 
+import copy
 import json
 import os
 import StringIO
 import sys
 import unittest
 import urlparse
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from testing_support.auto_stub import TestCase
@@ skipping 240 matching lines @@
     self.mock(subprocess2, 'check_output', self._mocked_call)
     self.mock(subprocess2, 'communicate',
               lambda *a, **kw: ([self._mocked_call(*a, **kw), ''], 0))
     self.mock(git_cl.gclient_utils, 'CheckCallAndFilter', self._mocked_call)
     self.mock(git_common, 'is_dirty_git_tree', lambda x: False)
     self.mock(git_common, 'get_or_create_merge_base',
               lambda *a: (
                   self._mocked_call(['get_or_create_merge_base']+list(a))))
     self.mock(git_cl, 'BranchExists', lambda _: True)
     self.mock(git_cl, 'FindCodereviewSettingsFile', lambda: '')
+    self.mock(git_cl, 'time_sleep',
+              lambda seconds: self._mocked_call(['time_sleep', seconds]))
+    self.mock(git_cl, 'time_time', lambda: self._mocked_call(['time_time']))
     self.mock(git_cl, 'ask_for_data', self._mocked_call)
     self.mock(git_cl, 'write_json', lambda path, contents:
         self._mocked_call('write_json', path, contents))
     self.mock(git_cl.presubmit_support, 'DoPresubmitChecks', PresubmitMock)
     self.mock(git_cl.rietveld, 'Rietveld', RietveldMock)
     self.mock(git_cl.rietveld, 'CachingRietveld', RietveldMock)
     self.mock(git_cl.upload, 'RealMain', self.fail)
     self.mock(git_cl.watchlists, 'Watchlists', WatchlistsMock)
     self.mock(git_cl.auth, 'get_authenticator_for_host', AuthenticatorMock)
     self.mock(git_cl.gerrit_util.GceAuthenticator, 'is_gce',
@@ skipping 1801 matching lines @@
               self._mocked_call(['_buildbucket_retry']))
 
   def _setup_fetch_try_jobs_rietveld(self, *request_results):
     self._setup_fetch_try_jobs(most_recent_patchset=20001)
     self.calls += [
       ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
       ((['git', 'config', 'branch.feature.rietveldissue'],), '1'),
       ((['git', 'config', 'rietveld.autoupdate'],), CERR1),
       ((['git', 'config', 'rietveld.server'],), 'codereview.example.com'),
       ((['git', 'config', 'branch.feature.rietveldpatchset'],), '20001'),
+      ((['time_time'],), 1000.0),
       ((['git', 'config', 'branch.feature.rietveldserver'],),
        'codereview.example.com'),
       ((['get_authenticator_for_host', 'codereview.example.com'],),
        AuthenticatorMock()),
-    ] + [((['_buildbucket_retry'],), r) for r in request_results]
+    ] + [((['_buildbucket_retry'],), copy.deepcopy(r)) for r in request_results]
 
   def test_fetch_try_jobs_none_rietveld(self):
     self._setup_fetch_try_jobs_rietveld({})
     # Simulate that user isn't logged in.
     self.mock(AuthenticatorMock, 'has_cached_credentials', lambda _: False)
     self.assertEqual(0, git_cl.main(['try-results']))
     self.assertRegexpMatches(sys.stdout.getvalue(),
                              'Warning: Some results might be missing')
     self.assertRegexpMatches(sys.stdout.getvalue(), 'No try jobs')
 
   def test_fetch_try_jobs_some_rietveld(self):
     self._setup_fetch_try_jobs_rietveld({
       'builds': self.BUILDBUCKET_BUILDS_MAP.values(),
     })
     self.assertEqual(0, git_cl.main(['try-results']))
     self.assertRegexpMatches(sys.stdout.getvalue(), '^Failures:')
     self.assertRegexpMatches(sys.stdout.getvalue(), 'Started:')
     self.assertRegexpMatches(sys.stdout.getvalue(), '2 try jobs')
 
   def _setup_fetch_try_jobs_gerrit(self, *request_results):
     self._setup_fetch_try_jobs(most_recent_patchset=13)
     self.calls += [
       ((['git', 'symbolic-ref', 'HEAD'],), 'feature'),
       ((['git', 'config', 'branch.feature.rietveldissue'],), CERR1),
       ((['git', 'config', 'branch.feature.gerritissue'],), '1'),
       # Simulate that Gerrit has more patchsets than local.
       ((['git', 'config', 'branch.feature.gerritpatchset'],), '12'),
+      ((['time_time'],), 1000.0),
       ((['git', 'config', 'branch.feature.gerritserver'],),
        'https://x-review.googlesource.com'),
       ((['get_authenticator_for_host', 'x-review.googlesource.com'],),
        AuthenticatorMock()),
-    ] + [((['_buildbucket_retry'],), r) for r in request_results]
+    ] + [((['_buildbucket_retry'],), copy.deepcopy(r)) for r in request_results]
 
   def test_fetch_try_jobs_none_gerrit(self):
     self._setup_fetch_try_jobs_gerrit({})
     self.assertEqual(0, git_cl.main(['try-results']))
     self.assertRegexpMatches(
         sys.stdout.getvalue(),
         r'Warning: Codereview server has newer patchsets \(13\)')
     self.assertRegexpMatches(sys.stdout.getvalue(), 'No try jobs')
 
   def test_fetch_try_jobs_some_gerrit(self):
     self._setup_fetch_try_jobs_gerrit({
       'builds': self.BUILDBUCKET_BUILDS_MAP.values(),
     })
     # Explicit --patchset means actual local patchset doesn't matter.
     self.calls.remove(
         ((['git', 'config', 'branch.feature.gerritpatchset'],), '12'))
     self.assertEqual(0, git_cl.main(['try-results', '--patchset', '5']))
 
     # ... and doesn't result in warning.
     self.assertNotRegexpMatches(sys.stdout.getvalue(), 'Warning')
     self.assertRegexpMatches(sys.stdout.getvalue(), '^Failures:')
     self.assertRegexpMatches(sys.stdout.getvalue(), 'Started:')
     self.assertRegexpMatches(sys.stdout.getvalue(), '2 try jobs')
 
+  def test_fetch_try_jobs_some_gerrit_wait(self):
+    # Sort jobs by ID for determinism.
+    some_incomplete = copy.deepcopy([
+      b for _, b in sorted(self.BUILDBUCKET_BUILDS_MAP.iteritems())])
+    self.assertEqual(some_incomplete[0]['id'], '8000')
+    self.assertEqual(some_incomplete[0]['status'], 'COMPLETED')
+    self.assertEqual(some_incomplete[1]['id'], '9000')
+    self.assertEqual(some_incomplete[1]['status'], 'STARTED')
+    all_complete = copy.deepcopy(some_incomplete)
+    all_complete[1]['status'] = 'COMPLETED'
+
+    self._setup_fetch_try_jobs_gerrit({'builds': some_incomplete})
+    self.calls += [
+      ((['time_time'],), 1010.0),
+      ((['time_sleep', 10],), None),
+      ((['get_authenticator_for_host', 'x-review.googlesource.com'],),
+       AuthenticatorMock()),
+      ((['_buildbucket_retry'],), {'builds': all_complete}),
+    ]
+    self.assertEqual(0, git_cl.main(['try-results', '-w']))
+
+  def test_fetch_try_jobs_gerrit_wait_timeout(self):
+    self._setup_fetch_try_jobs_gerrit({
+      'builds': self.BUILDBUCKET_BUILDS_MAP.values(),  # Not all complete.
+    })
+    self.calls += [
+      ((['time_time'],), 1000.0 + 60 * 60 + 1), # Simulate running for too long.
+    ]
+    self.assertEqual(3, git_cl.main(['try-results', '-w']))
+
 
 if __name__ == '__main__':
   git_cl.logging.basicConfig(
       level=git_cl.logging.DEBUG if '-v' in sys.argv else git_cl.logging.ERROR)
   unittest.main()