refactor presubmit parsing code from git-cl into presubmit

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2010 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 is too confused.
 # pylint: disable=E1101,E1103,W0212,W0403
 
@@ skipping 120 matching lines @@
 
   _INHERIT_SETTINGS = 'inherit-review-settings-ok'
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'Change', 'DoGetTrySlaves', 'DoPresubmitChecks',
       'GetTrySlavesExecuter', 'GitAffectedFile', 'GitChange',
       'InputApi', 'ListRelevantPresubmitFiles', 'Main',
       'NotImplementedException', 'OutputApi', 'ParseFiles',
-      'PresubmitExecuter', 'PromptYesNo', 'ScanSubDirs',
+      'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'cPickle', 'cStringIO',
       'exceptions', 'fnmatch', 'gclient_utils', 'glob', 'json',
       'logging', 'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'scm', 'subprocess',
       'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest', 'urllib2',
       'warn',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
@@ skipping 252 matching lines @@
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     presubmit.os.path.isfile(root_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gclient_utils.FileRead(root_path,
                                      'rU').AndReturn(self.presubmit_text)
     presubmit.gclient_utils.FileRead(haspresubmit_path,
                                      'rU').AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
-    output = StringIO.StringIO()
     input_buf = StringIO.StringIO('y\n')
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, None, False))
+    output = presubmit.DoPresubmitChecks(
+        change, False, True, None, input_buf, None, False)
+    self.failIf(output.should_continue())
     self.assertEqual(output.getvalue().count('!!'), 2)
-    self.checkstdout('Running presubmit hooks...\n')
+    self.assertEqual(output.getvalue().count('Running presubmit hooks...\n'), 1)
 
   def testDoPresubmitChecksPromptsAfterWarnings(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit', 'PRESUBMIT.py')
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
     for _ in range(2):
       presubmit.os.path.isfile(inherit_path).AndReturn(False)
       presubmit.os.path.isfile(presubmit_path).AndReturn(True)
       presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
       presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
       presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
-    output = StringIO.StringIO()
     input_buf = StringIO.StringIO('n\n')  # say no to the warning
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, None, True))
+    output = presubmit.DoPresubmitChecks(
+        change, False, True, None, input_buf, None, True)
+    self.failIf(output.should_continue())
     self.assertEqual(output.getvalue().count('??'), 2)
 
-    output = StringIO.StringIO()
     input_buf = StringIO.StringIO('y\n')  # say yes to the warning
-    self.failUnless(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, None, True))
+    output = presubmit.DoPresubmitChecks(
+        change, False, True, None, input_buf, None, True)
+    self.failUnless(output.should_continue())
     self.assertEquals(output.getvalue().count('??'), 2)
-    self.checkstdout('Running presubmit hooks...\nRunning presubmit hooks...\n')
+    self.assertEqual(output.getvalue().count('Running presubmit hooks...\n'), 1)
 
   def testDoPresubmitChecksNoWarningPromptIfErrors(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123',
                          'REALLYNOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit',
                              'PRESUBMIT.py')
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     presubmit.os.path.isfile(presubmit_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
                                      ).AndReturn(self.presubmit_text)
     presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU').AndReturn(
         self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
-    output = StringIO.StringIO()
-    input_buf = StringIO.StringIO()  # should be unused
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, None, False))
+    output = presubmit.DoPresubmitChecks(change, False, True, None, None,
+        None, False)
     self.assertEqual(output.getvalue().count('??'), 2)
     self.assertEqual(output.getvalue().count('XX!!XX'), 2)
     self.assertEqual(output.getvalue().count('(y/N)'), 0)
-    self.checkstdout('Running presubmit hooks...\n')
+    self.assertEqual(output.getvalue().count('Running presubmit hooks...\n'), 1)
 
   def testDoDefaultPresubmitChecksAndFeedback(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     DEFAULT_SCRIPT = """
 def CheckChangeOnUpload(input_api, output_api):
   return [output_api.PresubmitError("!!")]
 def CheckChangeOnCommit(input_api, output_api):
   raise Exception("Test error")
 """
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     presubmit.os.path.isfile(join(self.fake_root_dir, 'PRESUBMIT.py')
         ).AndReturn(False)
     presubmit.os.path.isfile(join(self.fake_root_dir,
                                   'haspresubmit',
                                   'PRESUBMIT.py')).AndReturn(False)
     presubmit.random.randint(0, 4).AndReturn(0)
     self.mox.ReplayAll()
 
-    output = StringIO.StringIO()
     input_buf = StringIO.StringIO('y\n')
     # Always fail.
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(
-        change, False, True, output, input_buf, DEFAULT_SCRIPT, False))
-    text = ('Warning, no presubmit.py found.\n'
+    output = presubmit.DoPresubmitChecks(
+        change, False, True, None, input_buf, DEFAULT_SCRIPT, False)
+    self.failIf(output.should_continue())
+    text = ('Running presubmit hooks...\n'
+            'Warning, no presubmit.py found.\n'
             'Running default presubmit script.\n'
             '** Presubmit ERRORS **\n!!\n\n'
             'Was the presubmit check useful? Please send feedback & hate mail '
             'to maruel@chromium.org!\n')
     self.assertEquals(output.getvalue(), text)
-    self.checkstdout('Running presubmit hooks...\n')
 
   def testDirectoryHandling(self):
     files = [
       ['A', 'isdir'],
       ['A', presubmit.os.path.join('isdir', 'blat.cc')],
     ]
     isdir = presubmit.os.path.join(self.fake_root_dir, 'isdir')
     blat = presubmit.os.path.join(isdir, 'blat.cc')
     presubmit.os.path.exists(isdir).AndReturn(True)
     presubmit.os.path.isdir(isdir).AndReturn(True)
@@ skipping 47 matching lines @@
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
     input_buf = StringIO.StringIO('y\n')
     change = presubmit.Change(
         'foo', "Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n",
         self.fake_root_dir, None, 0, 0)
     self.failUnless(presubmit.DoPresubmitChecks(
         change, False, True, output, input_buf, DEFAULT_SCRIPT, False))
     self.assertEquals(output.getvalue(),
-                      ('Warning, no presubmit.py found.\n'
+                      ('Running presubmit hooks...\n'
+                       'Warning, no presubmit.py found.\n'
                        'Running default presubmit script.\n'
                        '** Presubmit Messages **\n'
                        'http://tracker.com/42\n\n'))
-    self.checkstdout('Running presubmit hooks...\n')
 
   def testGetTrySlavesExecuter(self):
     self.mox.ReplayAll()
 
     executer = presubmit.GetTrySlavesExecuter()
     self.assertEqual([], executer.ExecPresubmitScript(''))
     self.assertEqual([], executer.ExecPresubmitScript('def foo():\n  return\n'))
 
     # bad results
     starts_with_space_result = ['  starts_with_space']
@@ skipping 52 matching lines @@
     self.mox.StubOutWithMock(presubmit, 'DoPresubmitChecks')
     self.mox.StubOutWithMock(presubmit, 'ParseFiles')
     presubmit.os.path.isdir(presubmit.os.path.join(self.fake_root_dir, '.svn')
         ).AndReturn(False)
     presubmit.os.path.isdir(presubmit.os.path.join(self.fake_root_dir, '.git')
         ).AndReturn(False)
     presubmit.subprocess.call(
         ['git', 'rev-parse', '--show-cdup'],
         cwd=self.fake_root_dir,
         stdout=presubmit.subprocess.PIPE).AndReturn(1)
+    output = self.mox.CreateMock(presubmit.PresubmitOutput)
+    output.should_continue().AndReturn(False)
+
     presubmit.DoPresubmitChecks(mox.IgnoreArg(), False, False,
                                 mox.IgnoreArg(),
                                 mox.IgnoreArg(),
-                                None, False).AndReturn(False)
+                                None, False).AndReturn(output)
     self.mox.ReplayAll()
 
     self.assertEquals(True,
                       presubmit.Main(['presubmit', '--root',
                                       self.fake_root_dir]))
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
@@ skipping 345 matching lines @@
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         False, None)
     input_api.ReadFile(fileobj, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
-      'MailTextResult', 'PresubmitAddText', 'PresubmitError',
+      'MailTextResult', 'PresubmitAddReviewers', 'PresubmitError',
       'PresubmitNotifyResult', 'PresubmitPromptWarning', 'PresubmitResult',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.OutputApi(), members)
 
   def testOutputApiBasics(self):
     self.mox.ReplayAll()
-    self.failUnless(presubmit.OutputApi.PresubmitError('').IsFatal())
-    self.failIf(presubmit.OutputApi.PresubmitError('').ShouldPrompt())
+    self.failUnless(presubmit.OutputApi.PresubmitError('').fatal)
+    self.failIf(presubmit.OutputApi.PresubmitError('').should_prompt)
 
-    self.failIf(presubmit.OutputApi.PresubmitPromptWarning('').IsFatal())
+    self.failIf(presubmit.OutputApi.PresubmitPromptWarning('').fatal)
     self.failUnless(
-        presubmit.OutputApi.PresubmitPromptWarning('').ShouldPrompt())
+        presubmit.OutputApi.PresubmitPromptWarning('').should_prompt)
 
-    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').IsFatal())
-    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').ShouldPrompt())
+    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').fatal)
+    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').should_prompt)
 
-    self.failIf(presubmit.OutputApi.PresubmitAddText('foo').IsFatal())
-    self.failIf(presubmit.OutputApi.PresubmitAddText('foo').ShouldPrompt())
+    self.failIf(presubmit.OutputApi.PresubmitAddReviewers(
+        ['foo']).fatal)
+    self.failIf(presubmit.OutputApi.PresubmitAddReviewers(
+        ['foo']).should_prompt)
 
     # TODO(joi) Test MailTextResult once implemented.
 
   def testOutputApiHandling(self):
     self.mox.ReplayAll()
 
-    output = StringIO.StringIO()
-    unused_input = StringIO.StringIO()
-    added_text = presubmit.OutputApi.PresubmitAddText('R=ben@example.com')
-    self.failUnless(added_text._Handle(output, unused_input))
-    self.failUnlessEqual(output.getvalue(), 'ADD: R=ben@example.com\n')
+    output = presubmit.PresubmitOutput()
+    presubmit.OutputApi.PresubmitAddReviewers(
+        ['ben@example.com']).handle(output)
+    self.failUnless(output.should_continue())
+    self.failUnlessEqual(output.reviewers, ['ben@example.com'])
 
-    output = StringIO.StringIO()
-    unused_input = StringIO.StringIO()
-    error = presubmit.OutputApi.PresubmitError('!!!')
-    self.failIf(error._Handle(output, unused_input))
+    output = presubmit.PresubmitOutput()
+    presubmit.OutputApi.PresubmitError('!!!').handle(output)
+    self.failIf(output.should_continue())
     self.failUnless(output.getvalue().count('!!!'))
 
-    output = StringIO.StringIO()
-    notify = presubmit.OutputApi.PresubmitNotifyResult('?see?')
-    self.failUnless(notify._Handle(output, unused_input))
+    output = presubmit.PresubmitOutput()
+    presubmit.OutputApi.PresubmitNotifyResult('?see?').handle(output)
+    self.failUnless(output.should_continue())
     self.failUnless(output.getvalue().count('?see?'))
 
-    output = StringIO.StringIO()
-    input_buf = StringIO.StringIO('y')
-    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failUnless(warning._Handle(output, input_buf))
+    output = presubmit.PresubmitOutput(input_stream=StringIO.StringIO('y'))
+    presubmit.OutputApi.PresubmitPromptWarning('???').handle(output)
+    output.prompt_yes_no('prompt: ')
+    self.failUnless(output.should_continue())
     self.failUnless(output.getvalue().count('???'))
 
-    output = StringIO.StringIO()
-    input_buf = StringIO.StringIO('n')
-    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failIf(warning._Handle(output, input_buf))
+    output = presubmit.PresubmitOutput(input_stream=StringIO.StringIO('y'))
+    presubmit.OutputApi.PresubmitPromptWarning('???').handle(output)
+    output.prompt_yes_no('prompt: ')
+    self.failUnless(output.should_continue())
     self.failUnless(output.getvalue().count('???'))
 
-    output = StringIO.StringIO()
-    input_buf = StringIO.StringIO('\n')
-    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failIf(warning._Handle(output, input_buf))
+    output = presubmit.PresubmitOutput(input_stream=StringIO.StringIO('\n'))
+    presubmit.OutputApi.PresubmitPromptWarning('???').handle(output)
+    output.prompt_yes_no('prompt: ')
+    self.failIf(output.should_continue())
     self.failUnless(output.getvalue().count('???'))
 
 
 class AffectedFileUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPath', 'Action', 'ChangedContents', 'GenerateScmDiff',
       'IsDirectory', 'IsTextFile', 'LocalPath', 'NewContents', 'OldContents',
       'OldFileTempPath', 'Property', 'ServerPath',
@@ skipping 740 matching lines @@
     self.mox.ReplayAll()
 
     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 OwnersTest(self, is_committing, tbr=False, change_tags=None,
       suggested_reviewers=None, approvers=None,
-      uncovered_files=None, expected_results=None):
+      uncovered_files=None, expected_reviewers=None, expected_output=''):
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file.LocalPath().AndReturn('foo.cc')
     change = self.mox.CreateMock(presubmit.Change)
     change.AffectedFiles(None).AndReturn([affected_file])
 
     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
@@ skipping 10 matching lines @@
           StringIO.StringIO(rietveld_response))
       input_api.json = presubmit.json
       fake_db.files_not_covered_by(set(['foo.cc']), approvers).AndReturn(
           uncovered_files)
     elif not is_committing:
       change.tags = change_tags
       if not change_tags.get('R'):
         fake_db.reviewers_for(set(['foo.cc'])).AndReturn(suggested_reviewers)
 
     self.mox.ReplayAll()
+    output = presubmit.PresubmitOutput()
     results = presubmit_canned_checks.CheckOwners(input_api,
         presubmit.OutputApi)
-    self.assertEquals(len(results), len(expected_results))
-    if results and expected_results:
-      output = StringIO.StringIO()
-      unused_input = StringIO.StringIO()
-      results[0]._Handle(output, unused_input)
-      self.assertEquals(output.getvalue(), expected_results[0])
+    if results:
+      results[0].handle(output)
+    if expected_reviewers is not None:
+      self.assertEquals(output.reviewers, expected_reviewers)
+    self.assertEquals(output.getvalue(), expected_output)
 
   def testCannedCheckOwners_WithReviewer(self):
-    self.OwnersTest(is_committing=False, change_tags={'R': 'ben@example.com'},
-        expected_results=[])
+    self.OwnersTest(is_committing=False, change_tags={'R': 'ben@example.com'})
     self.OwnersTest(is_committing=False, tbr=True,
-        change_tags={'R': 'ben@example.com'}, expected_results=[])
+        change_tags={'R': 'ben@example.com'})
 
   def testCannedCheckOwners_NoReviewer(self):
     self.OwnersTest(is_committing=False, change_tags={},
         suggested_reviewers=['ben@example.com'],
-        expected_results=['ADD: R=ben@example.com\n'])
+        expected_reviewers=['ben@example.com'])
     self.OwnersTest(is_committing=False, tbr=True, change_tags={},
         suggested_reviewers=['ben@example.com'],
-        expected_results=['ADD: R=ben@example.com\n'])
+        expected_reviewers=['ben@example.com'])
 
   def testCannedCheckOwners_CommittingWithoutOwnerLGTM(self):
     self.OwnersTest(is_committing=True,
         approvers=set(),
         uncovered_files=set(['foo.cc']),
-        expected_results=['Missing LGTM from an OWNER for: foo.cc\n'])
+        expected_output='Missing LGTM from an OWNER for: foo.cc\n')
 
   def testCannedCheckOwners_CommittingWithLGTMs(self):
     self.OwnersTest(is_committing=True,
         approvers=set(['ben@example.com']),
-        uncovered_files=set(),
-        expected_results=[])
+        uncovered_files=set())
 
   def testCannedCheckOwners_TBR(self):
     self.OwnersTest(is_committing=True, tbr=True,
         approvers=set(),
         uncovered_files=set(),
-        expected_results=['--tbr was specified, skipping OWNERS check\n'])
+        expected_output='--tbr was specified, skipping OWNERS check\n')
 
 if __name__ == '__main__':
   import unittest
   unittest.main()