Remove manual check using Rietveld for dry run.

tests/presubmit_unittest.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 presubmit_support.py and presubmit_canned_checks.py."""
 
 # pylint: disable=E1101,E1103
 
 import StringIO
@@ skipping 2545 matching lines @@
 
     results = presubmit_canned_checks.CheckBuildbotPendingBuilds(
         input_api, presubmit.OutputApi, 'uurl', 2, ('foo'))
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
         presubmit.OutputApi.PresubmitNotifyResult)
 
   def AssertOwnersWorks(self, tbr=False, issue='1', approvers=None,
       reviewers=None, is_committing=True, rietveld_response=None,
       uncovered_files=None, expected_output='',
-      manually_specified_reviewers=None, cq_dry_run=False):
+      manually_specified_reviewers=None, dry_run=None):
     if approvers is None:
       # The set of people who lgtm'ed a change.
       approvers = set()
     if reviewers is None:
       # The set of people needed to lgtm a change. We default to
       # the same list as the people who approved it. We use 'reviewers'
       # to avoid a name collision w/ owners.py.
       reviewers = approvers
     if uncovered_files is None:
       uncovered_files = set()
     if manually_specified_reviewers is None:
       manually_specified_reviewers = []
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
     change.author_email = 'john@example.com'
     change.R = ','.join(manually_specified_reviewers)
     change.TBR = ''
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api = self.MockInputApi(change, False)
     fake_db = self.mox.CreateMock(owners.Database)
     fake_db.email_regexp = input_api.re.compile(owners.BASIC_EMAIL_REGEXP)
     input_api.owners_db = fake_db
     input_api.is_committing = is_committing
     input_api.tbr = tbr
+    input_api.dry_run = dry_run
 
     if not is_committing or (not tbr and issue):
-      if not cq_dry_run:
+      if not dry_run:
         affected_file.LocalPath().AndReturn('foo/xyz.cc')
         change.AffectedFiles(file_filter=None).AndReturn([affected_file])
       if issue and not rietveld_response:
         rietveld_response = {
           "owner_email": change.author_email,
           "messages": [
             {"sender": a, "text": "I approve", "approval": True}
             for a in approvers
           ],
           "reviewers": reviewers
         }
 
       if is_committing:
         people = approvers
-        if issue:
-          input_api.rietveld.get_issue_properties(
-              issue=int(input_api.change.issue), messages=None).AndReturn(
-                  rietveld_response)
       else:
         people = reviewers
 
-      if not cq_dry_run:
+      if not dry_run:
         if issue:
           input_api.rietveld.get_issue_properties(
               issue=int(input_api.change.issue), messages=True).AndReturn(
                   rietveld_response)
 
         people.add(change.author_email)
         fake_db.files_not_covered_by(set(['foo/xyz.cc']),
             people).AndReturn(uncovered_files)
         if not is_committing and uncovered_files:
           fake_db.reviewers_for(set(['foo']),
               change.author_email).AndReturn(change.author_email)
 
     self.mox.ReplayAll()
     output = presubmit.PresubmitOutput()
     results = presubmit_canned_checks.CheckOwners(input_api,
         presubmit.OutputApi)
     if results:
       results[0].handle(output)
     self.assertEquals(output.getvalue(), expected_output)
 
   def testCannedCheckOwners_DryRun(self):
     response = {
       "owner_email": "john@example.com",
-      "cq_dry_run": True,
       "reviewers": ["ben@example.com"],
     }
     self.AssertOwnersWorks(approvers=set(),
-        cq_dry_run=True,
+        dry_run=True,
         rietveld_response=response,
         reviewers=set(["ben@example.com"]),
         expected_output='This is a dry run, skipping OWNERS check\n')
 
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
         is_committing=False,
         rietveld_response=response,
         expected_output='')
 
   def testCannedCheckOwners_Approved(self):
@@ skipping 235 matching lines @@
         owners_check=False)
     self.assertEqual(2, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()