Reduce spam from CQ.

tests/pending_manager_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 pending_manager.py."""
 
 import logging
 import os
 import re
@@ skipping 88 matching lines @@
               'prepare(None)',  # Will sync to HEAD/124.
               'apply_patch(%r)' % (self.context.rietveld.patchsets[1],),
               (
                 "commit(u'foo\\n\\n"
                 "Review URL: http://nowhere/%d', "
                 "u'author@example.com')") % issue])
         self.context.rietveld.check_calls(
             [ _try_comment(),
               'close_issue(%d)' % issue,
               "update_description(%d, u'foo')" % issue,
+              "set_flag(%d, 1, 'commit', False)" % issue,
               "add_comment(%d, 'Change committed as 125')" % issue])
       else:
         self.context.checkout.check_calls(
             [ 'prepare(None)',
               'apply_patch(%r)' % (self.context.rietveld.patchsets[0],)])
         self.context.rietveld.check_calls(
             [ _try_comment(),
               "set_flag(%d, 1, 'commit', False)" % issue,
               "add_comment(%d, %r)" % (issue, fake.failed_message())])
     else:
       if success:
         self.context.checkout.check_calls(
           self._prepare_apply_commit(0, issue))
         self.context.rietveld.check_calls(
             [ _try_comment(),
               'close_issue(%d)' % issue,
               "update_description(%d, u'foo')" % issue,
+              "set_flag(%d, 1, 'commit', False)" % issue,
               "add_comment(%d, 'Change committed as 125')" % issue])
       else:
         # checkout is never touched in that case.
         self.context.checkout.check_calls([])
         if defered:
           self.context.rietveld.check_calls(
               [ _try_comment(),
                 "set_flag(%d, 1, 'commit', False)" % issue,
                 "add_comment(%d, %r)" % (issue, fake.failed_message())])
         else:
@@ skipping 67 matching lines @@
     if result == base.FAILED:
       self.assertEqual([], pc.queue.iterate())
     else:
       commit = pc.queue.get(issue)
       self.assertEqual(commit.verifications['fake'].get_state(), result)
       self.assertEqual('', commit.relpath)
       self.assertEqual(len(commit.verifications), 1)
     self._check_standard_verification(pc, result == base.SUCCEEDED, False)
 
     if result == base.SUCCEEDED:
-      self.context.status.check_names(['initial', 'why not', 'commit'])
+      self.context.status.check_names(
+        ['initial', 'why not', 'commit', 'abort'])
     elif send_initial_packet:
       self.context.status.check_names(['initial', 'abort'])
     else:
       # Only happens when there is no verifier that requires a patch.
       self.context.status.check_names(['abort'])
 
   def testNoPatchVerification(self):
     pc = self._get_pc([fake.FakeVerifier(base.SUCCEEDED)], [])
     self._check_1(pc, base.SUCCEEDED)
 
@@ skipping 58 matching lines @@
     self.assertEqual(commit.verifications['fake'].get_state(), base.PROCESSING)
     self.assertEqual(len(commit.verifications), 1)
     pc.update_status()
     commit = pc.queue.get(issue)
     self.assertEqual('', commit.relpath)
     self.assertEqual(commit.verifications['fake'].get_state(), result)
     self.assertEqual(len(commit.verifications), 1)
     self._check_standard_verification(pc, result == base.SUCCEEDED, True)
     if result == base.SUCCEEDED:
       self.context.status.check_names(['initial', 'why not', 'why not',
-                                       'why not', 'commit'])
+                                       'why not', 'commit', 'abort'])
     else:
       self.context.status.check_names(['initial', 'why not', 'why not',
                                        'abort'])
 
   def testDeferNoPatchVerification(self):
     pc = self._get_pc([fake.DeferredFakeVerifier(base.SUCCEEDED, 0)], [])
     self._check_defer_1(pc, base.SUCCEEDED)
 
   def testDeferPatchVerification(self):
     pc = self._get_pc([], [fake.DeferredFakeVerifier(base.SUCCEEDED, 0)])
@@ skipping 46 matching lines @@
     else:
       commit = pc.queue.get(issue)
       self.assertEqual(commit.verifications['fake1'].get_state(), f1)
       self.assertEqual(commit.verifications['fake2'].get_state(), f2)
       self.assertEqual(commit.verifications['fake3'].get_state(), f3)
       self.assertEqual(commit.verifications['fake4'].get_state(), f4)
       self.assertEqual(len(commit.verifications), nb)
     self._check_standard_verification(
         pc, all(x == base.SUCCEEDED for x in (f1, f2, f3, f4)), False)
     if all(x == base.SUCCEEDED for x in (f1, f2, f3, f4)):
-      self.context.status.check_names(['initial', 'why not', 'commit'])
+      self.context.status.check_names(['initial', 'why not', 'commit', 'abort'])
     else:
       self.context.status.check_names(['initial', 'abort'])
 
   def test4thVerificationFail(self):
     self._check_4(base.SUCCEEDED, base.SUCCEEDED, base.SUCCEEDED, base.FAILED)
 
   def test4Verification(self):
     self._check_4(
         base.SUCCEEDED, base.SUCCEEDED, base.SUCCEEDED, base.SUCCEEDED)
 
@@ skipping 30 matching lines @@
     pc.update_status()
     self.assertEqual(commit.verifications['fake1'].get_state(), f1)
     self.assertEqual(commit.verifications['fake2'].get_state(), f2)
     self.assertEqual(commit.verifications['fake3'].get_state(), f3)
     self.assertEqual(commit.verifications['fake4'].get_state(), f4)
     self.assertEqual('', commit.relpath)
     self._check_standard_verification(
         pc, all(x == base.SUCCEEDED for x in (f1, f2, f3, f4)), False)
     if all(x == base.SUCCEEDED for x in (f1, f2, f3, f4)):
       self.context.status.check_names(['initial', 'why not', 'why not',
-                                       'why not', 'commit'])
+                                       'why not', 'commit', 'abort'])
     else:
       self.context.status.check_names(['initial', 'why not', 'why not',
                                        'abort'])
 
   def testDefer4thVerificationFail(self):
     self._check_defer_4(
         base.SUCCEEDED, base.SUCCEEDED, base.SUCCEEDED, base.FAILED)
 
   def testDefer4Verification(self):
     self._check_defer_4(
@@ skipping 21 matching lines @@
     pc.update_status()
     self.context.checkout.check_calls([])
     pc.scan_results()
     self.context.checkout.check_calls(
         # Will sync to HEAD, 124.
         self._prepare_apply_commit(1, issue))
     self.context.rietveld.check_calls(
         [ _try_comment(),
           'close_issue(%d)' % issue,
           "update_description(%d, u'foo')" % issue,
+          "set_flag(%d, 1, 'commit', False)" % issue,
           "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['initial', 'why not', 'commit'])
+    self.context.status.check_names(['initial', 'why not', 'commit', 'abort'])
 
   def testCommitBurst(self):
     issue = 31337
     pc = self._get_pc([fake.FakeVerifier(base.SUCCEEDED)], [])
     self.assertEqual(4, pc.MAX_COMMIT_BURST)
     timestamp = [1]
     self.mock(time, 'time', lambda: timestamp[-1])
     for i in range(pc.MAX_COMMIT_BURST + 2):
       self.context.rietveld.issues[i] = (
           self.context.rietveld.issues[issue].copy())
@@ skipping 11 matching lines @@
     self.context.rietveld.check_calls(
         [ _try_comment(0),
           _try_comment(1),
           _try_comment(2),
           _try_comment(3),
           _try_comment(4),
           _try_comment(5),
           _try_comment(),
           'close_issue(0)',
           "update_description(0, u'foo')",
+          "set_flag(0, 1, 'commit', False)",
           "add_comment(0, 'Change committed as 125')",
           'close_issue(1)',
           "update_description(1, u'foo')",
+          "set_flag(1, 1, 'commit', False)",
           "add_comment(1, 'Change committed as 125')",
           'close_issue(2)',
           "update_description(2, u'foo')",
+          "set_flag(2, 1, 'commit', False)",
           "add_comment(2, 'Change committed as 125')",
           'close_issue(3)',
           "update_description(3, u'foo')",
+          "set_flag(3, 1, 'commit', False)",
           "add_comment(3, 'Change committed as 125')",
         ])
     self.assertEqual(3, len(pc.queue.iterate()))
     total = pc.MAX_COMMIT_BURST + 3
     self.context.status.check_names(['initial'] * total +
-                                    (['why not', 'commit'] *
+                                    (['why not', 'commit', 'abort'] *
                                      pc.MAX_COMMIT_BURST) +
                                     ['why not'] * 3)
 
     # Dry run.
     pc.scan_results()
     self.context.checkout.check_calls([])
     self.context.rietveld.check_calls([])
     self.context.status.check_names(['why not'] * 3)
 
     # Remove one item from the burst.
     pc.recent_commit_timestamps.pop()
     pc.scan_results()
     next_item = pc.MAX_COMMIT_BURST
     self.context.checkout.check_calls(
         self._prepare_apply_commit(next_item, next_item))
     self.context.rietveld.check_calls(
         [ 'close_issue(%d)' % next_item,
           "update_description(%d, u'foo')" % next_item,
+          "set_flag(%d, 1, 'commit', False)" % next_item,
           "add_comment(%d, 'Change committed as 125')" % next_item,
         ])
-    self.context.status.check_names(['why not', 'commit'] + ['why not'] * 2)
+    self.context.status.check_names(['why not', 'commit', 'abort'] +
+                                    ['why not'] * 2)
     # After a delay, must flush the queue.
     timestamp.append(timestamp[-1] + pc.COMMIT_BURST_DELAY + 1)
     pc.scan_results()
     self.context.checkout.check_calls(
         self._prepare_apply_commit(next_item + 1, next_item + 1) +
         self._prepare_apply_commit(next_item + 2, issue))
     self.context.rietveld.check_calls(
         [ 'close_issue(%d)' % (next_item + 1),
           "update_description(%d, u'foo')" % (next_item + 1),
+          "set_flag(%d, 1, 'commit', False)" % (next_item + 1),
           "add_comment(%d, 'Change committed as 125')" % (next_item + 1),
           'close_issue(%d)' % issue,
           "update_description(%d, u'foo')" % issue,
+          "set_flag(%d, 1, 'commit', False)" % issue,
           "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['why not', 'commit'] * 2)
+    self.context.status.check_names(['why not', 'commit', 'abort'] * 2)
 
   def testIgnored(self):
     issue = 31337
     verifiers = [
         project_base.ProjectBaseUrlVerifier(
           [r'^%s(.*)$' % re.escape(r'http://example.com/')]),
     ]
     pc = self._get_pc(verifiers, [])
     pc.context.rietveld.issues[issue]['base_url'] = 'http://unrelated.com/sub'
     pc.look_for_new_pending_commit()
@@ skipping 14 matching lines @@
     pc = self._get_pc(verifiers, [])
     pc.context.rietveld.issues[issue]['base_url'] = 'http://example.com/'
     pc.look_for_new_pending_commit()
     pc.process_new_pending_commit()
     pc.update_status()
     pc.scan_results()
     self.context.rietveld.check_calls(
         [ _try_comment(),
           'close_issue(%d)' % issue,
           "update_description(%d, u'foo')" % issue,
+          "set_flag(%d, 1, 'commit', False)" % issue,
           "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['initial', 'why not', 'commit'])
+    self.context.status.check_names(['initial', 'why not', 'commit', 'abort'])
     self.context.checkout.check_calls(
         self._prepare_apply_commit(0, issue, server_hooks_missing=True))
 
   def testDisappeared(self):
     issue = 31337
     verifiers = [
         project_base.ProjectBaseUrlVerifier(
           [r'^%s(.*)$' % re.escape(r'http://example.com/')]),
     ]
     pc = self._get_pc(verifiers, [])
@@ skipping 60 matching lines @@
     pc.process_new_pending_commit()
     self.assertEqual(1, len(pc.queue.iterate()))
     pc.update_status()
     self.assertEqual(1, len(pc.queue.iterate()))
     pc.scan_results()
     self.assertEqual(0, len(pc.queue.iterate()))
     self.context.rietveld.check_calls(
         [ _try_comment(),
           'close_issue(%d)' % issue,
           "update_description(%d, u'foo')" % issue,
+          "set_flag(%d, 1, 'commit', False)" % issue,
           "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['initial', 'why not', 'commit'])
+    self.context.status.check_names(['initial', 'why not', 'commit', 'abort'])
     self.context.checkout.check_calls(
         self._prepare_apply_commit(0, issue))
 
   def testDriveBy(self):
     issue = 31337
     pc = self._get_pc_reviewer()
     self._approve()
     pc.look_for_new_pending_commit()
     pc.process_new_pending_commit()
     pc.update_status()
@@ skipping 18 matching lines @@
     # He's nice, he left a LGTM.
     i = self.context.rietveld.issues[issue]
     i['reviewers'] = i['reviewers'] + ['nice@dude.org']
     self._approve('nice@dude.org')
     pc.scan_results()
     self.assertEqual(0, len(pc.queue.iterate()))
     self.context.rietveld.check_calls(
         [ _try_comment(),
           'close_issue(%d)' % issue,
           "update_description(%d, u'foo')" % issue,
+          "set_flag(%d, 1, 'commit', False)" % issue,
           "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['initial', 'why not', 'commit'])
+    self.context.status.check_names(['initial', 'why not', 'commit', 'abort'])
     self.context.checkout.check_calls(
         self._prepare_apply_commit(0, issue))
 
   def testWhyNotUpdates(self):
     issue = 31337
     fake1_change = 1
     fake1 = fake.DeferredFakeVerifier(base.SUCCEEDED, fake1_change)
     fake1.name = 'fake1'
 
     fake2_change = 3
@@ skipping 10 matching lines @@
       expected = ['why not'] if fake1_change == i or fake2_change == i else []
       pc.update_status()
       self.context.status.check_names(expected)
 
     pc.scan_results()
 
     self.context.rietveld.check_calls(
       [_try_comment(),
        'close_issue(%d)' % issue,
        "update_description(%d, u'foo')" % issue,
+       "set_flag(%d, 1, 'commit', False)" % issue,
        "add_comment(%d, 'Change committed as 125')" % issue])
-    self.context.status.check_names(['why not', 'commit'])
+    self.context.status.check_names(['why not', 'commit', 'abort'])
     self.context.checkout.check_calls(
         self._prepare_apply_commit(0, issue))
 
 
 if __name__ == '__main__':
   logging.basicConfig(
       level=[logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG][
         min(sys.argv.count('-v'), 3)],
       format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
   unittest.main()